issue_owner_repo listlengths 2 2 | issue_body stringlengths 0 261k ⌀ | issue_title stringlengths 1 925 | issue_comments_url stringlengths 56 81 | issue_comments_count int64 0 2.5k | issue_created_at stringlengths 20 20 | issue_updated_at stringlengths 20 20 | issue_html_url stringlengths 37 62 | issue_github_id int64 387k 2.46B | issue_number int64 1 127k |
|---|---|---|---|---|---|---|---|---|---|
[
"chakra-core",
"ChakraCore"
] | ```
(function() {
"use asm";
m => 0;
})()
```
$ ~/chakracore/BuildLinux/Debug/ch 1case.js
ASSERTION 65750: (/home/skywinlinvm/chakracore/lib/Parser/Parse.cpp, line 5147) Deferring function parsing of a function does not handle lambda syntax
Failure: (!fLambda)
Illegal instruction (core dumped)
$ file ~/chakracore/BuildLinux/Debug/ch
/home/skywinlinvm/chakracore/BuildLinux/Debug/ch: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32
Git hash: 37690535b2ba477a5deeb421dab55f5344932db1
OS: Ubuntu Linux 16.04.1 LTS
Arch: x86_64
```
ASSERTION 65789: (/home/skywinlinvm/chakracore/lib/Parser/Parse.cpp, line 5147) Deferring function parsing of a function does not handle lambda syntax
Failure: (!fLambda)
Thread 1 "ch" received signal SIGILL, Illegal instruction.
0x00007ffff5ce855a in Parser::ParseFncDeclHelper<true> (this=0x7fffffffca30, pnodeFnc=0x7ff7f16a5800, pNameHint=0x0, flags=16, pHasName=0x7fffffff9adf, fUnaryOrParen=false, noStmtContext=false, pNeedScanRCurly=0x7fffffff9ab2,
skipFormals=false) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:5147
5147 AssertMsg(!fLambda, "Deferring function parsing of a function does not handle lambda syntax");
(gdb) bt
#0 0x00007ffff5ce855a in Parser::ParseFncDeclHelper<true> (this=0x7fffffffca30, pnodeFnc=0x7ff7f16a5800, pNameHint=0x0, flags=16, pHasName=0x7fffffff9adf, fUnaryOrParen=false, noStmtContext=false, pNeedScanRCurly=0x7fffffff9ab2,
skipFormals=false) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:5147
#1 0x00007ffff5cdfe80 in Parser::ParseFncDecl<true> (this=0x7fffffffca30, flags=16, pNameHint=0x0, needsPIDOnRCurlyScan=false, resetParsingSuperRestrictionState=false, fUnaryOrParen=false)
at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:4621
#2 0x00007ffff5ce3e9a in Parser::ParseExpr<true> (this=0x7fffffffca30, oplMin=0, pfCanAssign=0x0, fAllowIn=1, fAllowEllipsis=0, pNameHint=0x55555591ce1a u"m", pHintLength=0x0, pShortNameOffset=0x0, pToken=0x0,
fUnaryOrParen=false, pfLikelyPattern=0x0) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:8421
#3 0x00007ffff5cdecc1 in Parser::ParseStatement<true> (this=0x7fffffffca30) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:10209
#4 0x00007ffff5cc7aa7 in Parser::ParseStmtList<true> (this=0x7fffffffca30, ppnodeList=0x7ff7f16a5278, pppnodeLast=0x7fffffffa860, smEnvironment=Parser::SM_OnFunctionCode, isSourceElementList=true, strictModeOn=0x0)
at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:10478
#5 0x00007ffff5cb76d9 in Parser::FinishFncDecl (this=0x7fffffffca30, pnodeFnc=0x7ff7f16a5210, pNameHint=0x0, lastNodeRef=0x0, skipCurlyBraces=false) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:6858
#6 0x00007ffff5ce8b87 in Parser::ParseFncDeclHelper<true> (this=0x7fffffffca30, pnodeFnc=0x7ff7f16a5210, pNameHint=0x0, flags=0, pHasName=0x7fffffffad9f, fUnaryOrParen=true, noStmtContext=false, pNeedScanRCurly=0x7fffffffad72,
skipFormals=false) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:5274
#7 0x00007ffff5cdfe80 in Parser::ParseFncDecl<true> (this=0x7fffffffca30, flags=0, pNameHint=0x0, needsPIDOnRCurlyScan=false, resetParsingSuperRestrictionState=true, fUnaryOrParen=true)
at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:4621
#8 0x00007ffff5cf0b74 in Parser::ParseTerm<true> (this=0x7fffffffca30, fAllowCall=1, pNameHint=0x0, pHintLength=0x7fffffffb2e4, pShortNameOffset=0x7fffffffb2e0, pToken=0x7fffffffb320, fUnaryOrParen=true,
pfCanAssign=0x7fffffffb33c, pfLikelyPattern=0x7fffffffb284, pfIsDotOrIndex=0x7fffffffb33a) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:3165
#9 0x00007ffff5ce346f in Parser::ParseExpr<true> (this=0x7fffffffca30, oplMin=0, pfCanAssign=0x7fffffffb570, fAllowIn=1, fAllowEllipsis=0, pNameHint=0x0, pHintLength=0x0, pShortNameOffset=0x0, pToken=0x7fffffffb578,
fUnaryOrParen=true, pfLikelyPattern=0x0) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:8211
#10 0x00007ffff5cf02cb in Parser::ParseTerm<true> (this=0x7fffffffca30, fAllowCall=1, pNameHint=0x0, pHintLength=0x7fffffffb894, pShortNameOffset=0x7fffffffb890, pToken=0x7fffffffb8d0, fUnaryOrParen=false,
pfCanAssign=0x7fffffffb8ec, pfLikelyPattern=0x7fffffffb834, pfIsDotOrIndex=0x7fffffffb8ea) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:2953
#11 0x00007ffff5ce346f in Parser::ParseExpr<true> (this=0x7fffffffca30, oplMin=0, pfCanAssign=0x0, fAllowIn=1, fAllowEllipsis=0, pNameHint=0x0, pHintLength=0x0, pShortNameOffset=0x0, pToken=0x0, fUnaryOrParen=false,
pfLikelyPattern=0x0) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:8211
#12 0x00007ffff5cdecc1 in Parser::ParseStatement<true> (this=0x7fffffffca30) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:10209
#13 0x00007ffff5cc7aa7 in Parser::ParseStmtList<true> (this=0x7fffffffca30, ppnodeList=0x7ff7f16a5098, pppnodeLast=0x7fffffffc450, smEnvironment=Parser::SM_OnGlobalCode, isSourceElementList=true, strictModeOn=0x0)
at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:10478
#14 0x00007ffff5ca933b in Parser::Parse (this=0x7fffffffca30, pszSrc=0x5555558b87d0 "(function() {\n \"use asm\";\n m => 0;\n})()", offset=0, length=45, charOffset=0, grfscr=4096, lineNumber=0,
nextFunctionId=0x7ff7f1f1a284, pse=0x7fffffffd1d0) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:10999
#15 0x00007ffff5ca8553 in Parser::ParseSourceInternal (this=0x7fffffffca30, parseTree=0x7fffffffc848, pszSrc=0x5555558b87d0 "(function() {\n \"use asm\";\n m => 0;\n})()", offsetInBytes=0, encodedCharCount=45,
offsetInChars=0, fromExternal=true, grfscr=4096, pse=0x7fffffffd1d0, nextFunctionId=0x7ff7f1f1a284, lineNumber=0, sourceContextInfo=0x7ff7f1f1a280) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:378
#16 0x00007ffff5cba419 in Parser::ParseUtf8Source (this=0x7fffffffca30, parseTree=0x7fffffffc848, pSrc=0x5555558b87d0 "(function() {\n \"use asm\";\n m => 0;\n})()", length=45, grfsrc=4096, pse=0x7fffffffd1d0,
nextFunctionId=0x7ff7f1f1a284, sourceContextInfo=0x7ff7f1f1a280) at /home/skywinlinvm/chakracore/lib/Parser/Parse.cpp:11188
#17 0x00007ffff51a4e2f in Js::ScriptContext::ParseScript (this=0x55555590b450, parser=0x7fffffffca30, script=0x5555558b87d0 "(function() {\n \"use asm\";\n m => 0;\n})()", cb=45, pSrcInfo=0x7fffffffce90, pse=0x7fffffffd1d0,
ppSourceInfo=0x7fffffffce88, rootDisplayName=0x7ffff5e8d2f0 <Js::Constants::GlobalCode> u"Global code", loadScriptFlag=(LoadScriptFlag_Utf8Source | LoadScriptFlag_ExternalArrayBuffer), sourceIndex=0x7fffffffca2c,
scriptSource=0x7ff7f1f30050) at /home/skywinlinvm/chakracore/lib/Runtime/Base/ScriptContext.cpp:1846
#18 0x00007ffff51a539b in Js::ScriptContext::LoadScript (this=0x55555590b450, script=0x5555558b87d0 "(function() {\n \"use asm\";\n m => 0;\n})()", cb=45, pSrcInfo=0x7fffffffce90, pse=0x7fffffffd1d0,
ppSourceInfo=0x7fffffffce88, rootDisplayName=0x7ffff5e8d2f0 <Js::Constants::GlobalCode> u"Global code", loadScriptFlag=(LoadScriptFlag_Utf8Source | LoadScriptFlag_ExternalArrayBuffer), scriptSource=0x7ff7f1f30050)
at /home/skywinlinvm/chakracore/lib/Runtime/Base/ScriptContext.cpp:1891
#19 0x00007ffff4bd02d5 in RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73::operator()(Js::ScriptContext*, TTD::TTDJsRTActionResultAutoRecorder&) const (this=0x7fffffffd0d0, scriptContext=0x55555590b450, _actionEntryPopper=...) at /home/skywinlinvm/chakracore/lib/Jsrt/Jsrt.cpp:2928
#20 0x00007ffff4bcffc7 in _JsErrorCode ContextAPINoScriptWrapper<RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73>(RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73, bool, bool)::{lambda(Js::ScriptContext*)#1}::operator()(Js::ScriptContext*) const (this=0x7fffffffd058, scriptContext=0x55555590b450) at /home/skywinlinvm/chakracore/lib/Jsrt/JsrtInternal.h:293
#21 0x00007ffff4bcf8cd in ContextAPINoScriptWrapper_Core<_JsErrorCode ContextAPINoScriptWrapper<RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73>(RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73, bool, bool)::{lambda(Js::ScriptContext*)#1}>(_JsErrorCode ContextAPINoScriptWrapper<RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73>(RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73, bool, bool)::{lambda(Js::ScriptContext*)#1}, bool, bool) (fn=...,
allowInObjectBeforeCollectCallback=false, scriptExceptionAllowed=false) at /home/skywinlinvm/chakracore/lib/Jsrt/JsrtInternal.h:254
#22 0x00007ffff4ba47d8 in ContextAPINoScriptWrapper<RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73>(RunScriptCore(void*, unsigned char const*, unsigned long, LoadScriptFlag, unsigned long, char16_t const*, bool, _JsParseScriptAttributes, bool, void**)::$_73, bool, bool) (fn=..., allowInObjectBeforeCollectCallback=false,
scriptExceptionAllowed=false) at /home/skywinlinvm/chakracore/lib/Jsrt/JsrtInternal.h:291
#23 0x00007ffff4ba4689 in RunScriptCore (scriptSource=0x7ff7f1f30050, script=0x5555558b87d0 "(function() {\n \"use asm\";\n m => 0;\n})()", cb=45,
loadScriptFlag=(LoadScriptFlag_Utf8Source | LoadScriptFlag_ExternalArrayBuffer), sourceContext=0, sourceUrl=0x7ff7f16a0000 u"/home/skywinlinvm/testchakracore/1case.js", parseOnly=false,
parseAttributes=JsParseScriptAttributeNone, isSourceModule=false, result=0x0) at /home/skywinlinvm/chakracore/lib/Jsrt/Jsrt.cpp:2877
#24 0x00007ffff4ba72ce in CompileRun (scriptVal=0x7ff7f1f30050, sourceContext=0, sourceUrl=0x7ff7f1f09020, parseAttributes=JsParseScriptAttributeNone, result=0x0, parseOnly=false)
at /home/skywinlinvm/chakracore/lib/Jsrt/Jsrt.cpp:4336
#25 JsRun (scriptVal=0x7ff7f1f30050, sourceContext=0, sourceUrl=0x7ff7f1f09020, parseAttributes=JsParseScriptAttributeNone, result=0x0) at /home/skywinlinvm/chakracore/lib/Jsrt/Jsrt.cpp:4358
#26 0x000055555555eafe in ChakraRTInterface::JsRun (script=0x7ff7f1f30050, sourceContext=0, sourceUrl=0x7ff7f1f09020, parseAttributes=JsParseScriptAttributeNone, result=0x0)
at /home/skywinlinvm/chakracore/bin/ch/ChakraRtInterface.h:367
#27 0x000055555555ca92 in RunScript (fileName=0x5555558d5e90 "1case.js", fileContents=0x5555558b87d0 "(function() {\n \"use asm\";\n m => 0;\n})()", bufferValue=0x0,
fullPath=0x7fffffffd9c0 "/home/skywinlinvm/testchakracore/1case.js") at /home/skywinlinvm/chakracore/bin/ch/ch.cpp:321
#28 0x000055555555deb0 in ExecuteTest (fileName=0x5555558d5e90 "1case.js") at /home/skywinlinvm/chakracore/bin/ch/ch.cpp:594
#29 0x000055555555dfb0 in ExecuteTestWithMemoryCheck (fileName=0x5555558d5e90 "1case.js") at /home/skywinlinvm/chakracore/bin/ch/ch.cpp:642
#30 0x000055555555e4f0 in main (argc=2, c_argv=0x7fffffffdd38) at /home/skywinlinvm/chakracore/bin/ch/ch.cpp:869
(gdb)
```
| Assertion failure: "Deferring function parsing of a function does not handle lambda syntax" with "use asm" and arrow function | https://api.github.com/repos/chakra-core/ChakraCore/issues/2237/comments | 2 | 2016-12-18T04:02:14Z | 2017-05-24T03:18:41Z | https://github.com/chakra-core/ChakraCore/issues/2237 | 196,256,805 | 2,237 |
[
"chakra-core",
"ChakraCore"
] | **Steps to reproduce:**
1. Go to Settings > Time & Language > Region & Language > Additional date, time, & regional settings > Change date, time, or number formats.
2. Choose any format other than "Match Windows display language". In my case format is Russian (Russia), and my display language is English (United States).
3. Run [this demo](http://www.w3schools.com/jsref/tryit.asp?filename=tryjsref_nav_language).
**Result:**
`NavigatorLanguage.language` is `ru-RU` which is format language.
**Expected result:**
`NavigatorLanguage.language` is `en-US` which is Windows display language.
| `NavigatorLanguage.language` property reports format language instead of Windows display language | https://api.github.com/repos/chakra-core/ChakraCore/issues/2235/comments | 2 | 2016-12-17T02:57:59Z | 2016-12-17T03:15:55Z | https://github.com/chakra-core/ChakraCore/issues/2235 | 196,191,946 | 2,235 |
[
"chakra-core",
"ChakraCore"
] | It is often the case that regressions in daily configurations go unnoticed in PRs. I believe we can pick a representative sample of builds from other configurations which will catch issues without significantly bloating the number of checks we run per PR.
The extra checks we add will not be exhaustive because they won't cover all possible configurations, but the intent is to cover the ones that break most often. This means that we are more likely to catch regressions before they are checked-in, but we will still need to keep an eye on the daily builds in case of more unusual regressions.
# Slow Tests
**x64_debug** should catch the most likely Slow Test regressions.
# DisableJIT Tests
**x64_debug** should catch the most likely breaks in build and test.
# Legacy Tests
~~**x64_release**~~ [1] **x64_debug** should catch the most frequent issues introduced in Legacy builds: compile errors ~~and PreFAST (static analysis) errors~~ [1] that are specific to the Dev12 compiler ~~, and which only run under Release builds~~ [1]. Test regressions are almost always because of Javascript semantics, so any test failures seen in Legacy builds are usually also seen in Slow Tests.
If the above is not sufficient, we could also add **x64_debug**. ~~However, **x64_release** build is a *must* because of the potential to introduce PreFAST issues.~~ [1]
**Edit:**
[1] Review of netci.groovy reveals that we are not running code analysis on dev12 because dev14 has superior analysis and dev12 gives false positives (see e95e58139dba8a81bce9ee02a989aed67f4c6b94). Because of this, I think it is more valuable to use **x64_debug** instead of **x64_release**.
----
/cc @Cellule
@obastemur While we're discussing this, it might be a good idea to discuss adding additional checks to cover the most commonly-broken scenarios for the x-plat builds we support.
Depending on the depth of discussion needed and the complexity of the changes there, we might make those changes at a later time / under a different issue. Because of the stabilization nature of the `release/1.4` branch I propose all new x-plat checks be added in master, but the new Windows builds should be added in `release/1.4` to aid with stabilization at this time. | Add one flavor each of Legacy and DisableJIT builds to PR checks to catch regressions | https://api.github.com/repos/chakra-core/ChakraCore/issues/2229/comments | 2 | 2016-12-16T23:41:53Z | 2017-01-30T22:34:06Z | https://github.com/chakra-core/ChakraCore/issues/2229 | 196,178,206 | 2,229 |
[
"chakra-core",
"ChakraCore"
] | Linux support would allow us to use a wider variety of static and dynamic analysis tools on the WASM code. | WASM: Linux Support | https://api.github.com/repos/chakra-core/ChakraCore/issues/2220/comments | 3 | 2016-12-16T02:20:24Z | 2017-02-23T12:15:29Z | https://github.com/chakra-core/ChakraCore/issues/2220 | 195,966,021 | 2,220 |
[
"chakra-core",
"ChakraCore"
] | In ChakraFull we POGO Test builds (rather than Release builds) because we need performance-optimized Test builds for testing purposes. The pogo_training.ps1 script is used to do the POGO training in ChakraFull as well. In the case of ChakraFull, extra parameters like `-oopjit-` work just fine.
We had not yet noticed the ChakraCore problem because we have not yet made a release of ChakraCore since these flags were added (they were not present in release/1.3, but the flag (currently -oopjit-) was added after OOP JIT was added to the code base to ensure we train without using OOP JIT.
OOP JIT is explicitly disabled by default in ChakraCore. Therefore, we can remove this additional flag for ChakraCore POGO, and move that flag into the appropriate automation specific to ChakraFull.
See discussion here: https://github.com/Microsoft/ChakraCore/pull/1793#issuecomment-267065346
/cc @matthargett | pogo_training.ps1 using `-oopjit-` flag breaks POGO training for ChakraCore release builds | https://api.github.com/repos/chakra-core/ChakraCore/issues/2213/comments | 3 | 2016-12-15T22:53:22Z | 2016-12-16T01:15:24Z | https://github.com/chakra-core/ChakraCore/issues/2213 | 195,937,903 | 2,213 |
[
"chakra-core",
"ChakraCore"
] | I have an attribute selector stored as a string. I pass it as an argument to `querySelectorAll` as in the code below. An error is thrown. See screenshot.
```
const ITEM = '[data-showflex="container"]',
STATECLASS = 'show';
function showAllItems() {
document.querySelectorAll(ITEM).forEach((item) => item.classList.add(STATECLASS));
}
function hideAllItems() {
document.querySelectorAll(ITEM).forEach((item) => item.classList.remove(STATECLASS));
}
```
| JavaScript Bug When Referencing Variable Storing Attribute Selector String | https://api.github.com/repos/chakra-core/ChakraCore/issues/2212/comments | 2 | 2016-12-15T21:05:19Z | 2017-01-06T00:10:40Z | https://github.com/chakra-core/ChakraCore/issues/2212 | 195,915,637 | 2,212 |
[
"chakra-core",
"ChakraCore"
] | After #1990 fixed #2026, another unrelated issue was revealed. It would be helpful to coordinate with @MikeHolman re #1990 to make sure both issues are fixed.
See logs from the errored tests under #1990. Error copied below:
```
19:21:40 D:\j\workspace\daily_dev12_x---c4e76fe7\Lib\Jsrt\ChakraCore.h(215): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int [D:\j\workspace\daily_dev12_x---c4e76fe7\bin\ch\ch.vcxproj]
19:21:40 D:\j\workspace\daily_dev12_x---c4e76fe7\Lib\Jsrt\ChakraCore.h(215): error C2143: syntax error : missing ',' before '*' [D:\j\workspace\daily_dev12_x---c4e76fe7\bin\ch\ch.vcxproj]
``` | [Legacy] Missing type | https://api.github.com/repos/chakra-core/ChakraCore/issues/2194/comments | 1 | 2016-12-12T22:54:30Z | 2016-12-15T23:08:57Z | https://github.com/chakra-core/ChakraCore/issues/2194 | 195,110,184 | 2,194 |
[
"chakra-core",
"ChakraCore"
] | When reading mutable value for globals `bool isMutable = ReadConst<UINT8>() == 1;`, we have to explicitly check for value 0 or 1 and throw if anything else | WASM - global mutable value | https://api.github.com/repos/chakra-core/ChakraCore/issues/2193/comments | 0 | 2016-12-12T22:15:44Z | 2016-12-20T22:15:38Z | https://github.com/chakra-core/ChakraCore/issues/2193 | 195,101,377 | 2,193 |
[
"chakra-core",
"ChakraCore"
] | This may not be the same Module API as what is currently available, but I figured most users would like a straight forward method to register custom Modules using the current strings api. For the most part the custom modules should automatically get cleaned out by garbage collection, and are straight forward on usage. This is a slight variation on issue #2112, but has a different approach and is meant for users who are embedding ChakraCore in cases where they do not wish to have the global object get polluted needlessly.
**Note:** This Feature request still has a lot of work needed for implementation, but in general the way to access the items contained from within the modules is to make use of the ```import``` keyword usage.
## New Data Types:
```C
/// <summary>
/// A module identifier.
/// </summary>
/// <remarks>
/// Module identifiers are used to refer to JavaScript Modules.
/// </remarks>
typedef JsRef JsModuleIdRef;
```
## New Functions
With this request there is a need for a few new functions to make this task easier to implement for users.
### JsCreateModuleId
This function works like the ```C JsCreatePropertyIdUtf8 ``` function except for it specifies a Module ID using the specified string.
``` C
/// <summary>
/// Creates the Module ID associated with a Custom C-Module.
/// </summary>
/// <remarks>
/// <para>
/// Module IDs are specific to a context and cannot be used across contexts.
/// </para>
/// <para>
/// Requires an active script context.
/// </para>
/// </remarks>
/// <param name="name">
/// The name of the Module ID to get or create. The name may consist of only digits.
/// The string is expected to be ASCII / utf8 encoded.
/// </param>
/// <param name="length">length of the name in bytes</param>
/// <param name="moduleId">The Module ID in this runtime for the given name.</param>
/// <returns>
/// The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
CHAKRA_API
JsCreateModuleId(
_In_z_ const char *name,
_In_ size_t length,
_Out_ JsModuleIdRef *moduleId);
```
### JsSetModuleProperty
This function is loosely based around the ```JsSetProperty``` function, but it instead places the new objects/Classes into the Module instead of the global object.
```C
/// <summary>
/// Puts a Module's property.
/// </summary>
/// <remarks>
/// Requires an active script context.
/// </remarks>
/// <param name="module">The module that contains the property.</param>
/// <param name="propertyId">The ID of the property.</param>
/// <param name="value">The new value of the property.</param>
/// <param name="useStrictRules">The property set should follow strict mode rules.</param>
/// <returns>
/// The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
/// </returns>
CHAKRA_API
JsSetModuleProperty(
_In_ JsModuleIdRef module,
_In_ JsPropertyIdRef propertyId,
_In_ JsValueRef value,
_In_ bool useStrictRules);
```
## Example Usage
Usage itself is relatively straight forward for those familiar with the current system. This example is loosely based on the Hello World and OpenGL Engine example.
```C
void setModuleCallback(JsModuleIdRef module, const char *propertyName, JsNativeFunction callback, void *callbackState)
{
JsPropertyIdRef propertyId;
JsValueRef function;
size_t properyNameLen = strlen(propertyName);
JsCreatePropertyIdUtf8(propertyName, propertyNameLen,&propertyId);
JsCreateFunction(callback, callbackState, &function);
JsSetModuleProperty(module, propertyId, function, true);
}
void registerConsole()
{
JsModuleIdRef moduleId;
const char *consoleName = "Console";
size_t consoleNameLen = strlen(consoleName);
JsCreateModuleId(consoleName,consoleNameLen,&moduleId)
setModuleCallback(moduleId, "log", JSLog, nullptr);
}
```
```JavaScript
/* This is from the C-API */
import * as MyConsole from "Console";
MyConsole.log("Hello World");
```
| Simplify C/C++ Module Creation | https://api.github.com/repos/chakra-core/ChakraCore/issues/2186/comments | 4 | 2016-12-12T02:35:54Z | 2018-05-07T22:11:19Z | https://github.com/chakra-core/ChakraCore/issues/2186 | 194,878,685 | 2,186 |
[
"chakra-core",
"ChakraCore"
] | `bin\ch\hostconfigflags.cpp(99): warning C6385: Reading invalid data from 'argv': the readable size is 'argc*8' bytes, but '24' bytes may be read.`
git blame shows this was introduced a few months ago:
```
10cfef1f (Michael Holman 2016-09-02 20:36:55 -0700 99) argv[i - 1] = argv[i];
```
Discovered when running code analysis on x64_debug build by following [these steps](https://github.com/Microsoft/ChakraCore/wiki/Jenkins-Repro-Steps#windows-release-builds).
Repros in x64_release on my machine. Not sure why it doesn't show up in Jenkins.
/cc @mmitche do you know why we would get different PreFAST errors locally versus on Jenkins? | [x64 release] bin\ch\hostconfigflags.cpp(99): warning C6385: Reading invalid data from 'argv' | https://api.github.com/repos/chakra-core/ChakraCore/issues/2183/comments | 1 | 2016-12-09T23:33:09Z | 2017-12-05T02:22:25Z | https://github.com/chakra-core/ChakraCore/issues/2183 | 194,722,765 | 2,183 |
[
"chakra-core",
"ChakraCore"
] | Are stack overflow exception supposed to throw WebAssembly.RuntimeError if they happen on a webassembly frame? | WASM - StackOverflow error as WebAssembly.RuntimeError | https://api.github.com/repos/chakra-core/ChakraCore/issues/2167/comments | 3 | 2016-12-08T02:08:33Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/2167 | 194,228,739 | 2,167 |
[
"chakra-core",
"ChakraCore"
] | Legacy builds are failing with the following error:
D:\j\workspace\daily_dev12_x---55cdd258\lib\Runtime\Library\WebAssemblyTable.cpp(124): error C2070: 'unknown': illegal sizeof operand [D:\j\workspace\daily_dev12_x---55cdd258\lib\Runtime\Library\Chakra.Runtime.Library.vcxproj]
Assigning as per last person to change the line, but PRs welcome. | Legacy builds failing on illegal sizeof | https://api.github.com/repos/chakra-core/ChakraCore/issues/2163/comments | 1 | 2016-12-07T20:33:29Z | 2016-12-09T23:37:06Z | https://github.com/chakra-core/ChakraCore/issues/2163 | 194,161,354 | 2,163 |
[
"chakra-core",
"ChakraCore"
] | As mentioned in https://github.com/Microsoft/ChakraCore/pull/2001#issuecomment-263711770
/cc @jianchun @mrkmarron | Update usage of JsTTDGetSnapTimeTopLevelEventMove in xplat branch | https://api.github.com/repos/chakra-core/ChakraCore/issues/2161/comments | 3 | 2016-12-07T04:01:00Z | 2017-05-17T22:39:24Z | https://github.com/chakra-core/ChakraCore/issues/2161 | 193,952,744 | 2,161 |
[
"chakra-core",
"ChakraCore"
] | Previously it has been noted by some members of the community that [ChakraCore Samples in the Chakra-Samples project](https://github.com/Microsoft/Chakra-Samples/tree/master/ChakraCore%20Samples) have not worked with the current ChakraCore master. These could be temporary regressions but they are not tracked by any automation or with any visible build badges, so it is not possible for the community to know whether they are expected to work.
It seems to me that we should have some kind of automation to ensure that Chakra-Samples continues to work. I think the most sensible place to add this (for community visibility) would be to the Chakra-Samples project itself. We could add Jenkins automation to clone ChakraCore master, build it, and then build the samples against it. That's the end-to-end scenario we plan to support. This also has the benefit of adding build scripts that show the full set of steps needed for the samples to work, and so would be valuable for documentation.
This unfortunately runs the risk of falling under the radar of the ChakraCore project maintainers, so we should, at a minimum, link from the Build Status table to the same daily build badges that indicate the health of the ChakraCore samples.
As a nice-to-have: having branches in Chakra-Samples and corresponding automation for master, the release milestone in progress (currently 1.4) and any supported releases (currently 1.2 and 1.3), will help users of ChakraCore find the Samples that work with the version of ChakraCore they are trying to build. Short of that, clearly indicating in a README under [ChakraCore Samples](https://github.com/Microsoft/Chakra-Samples/tree/master/ChakraCore%20Samples) which branch(es) of ChakraCore the samples are compatible with would be helpful as well.
See conversation here: https://github.com/Microsoft/ChakraCore/pull/2001#issuecomment-263720615
Related to: https://github.com/Microsoft/ChakraCore/pull/2136
/cc @obastemur @liminzhu | Add tests (here or in Chakra-Samples) to ensure ChakraCore Samples don't break. | https://api.github.com/repos/chakra-core/ChakraCore/issues/2160/comments | 6 | 2016-12-07T03:29:06Z | 2018-03-01T01:37:50Z | https://github.com/chakra-core/ChakraCore/issues/2160 | 193,949,110 | 2,160 |
[
"chakra-core",
"ChakraCore"
] | Due to the difference in argument permissibility for TypedArray constructors now, the baseline for this test no longer matches up with the output generated by running the test. I believe that the new output is correct, but assigning to Ian because he knows this change better. | Fix tests/typedarray/samethread.baseline | https://api.github.com/repos/chakra-core/ChakraCore/issues/2159/comments | 0 | 2016-12-07T03:21:56Z | 2016-12-17T02:40:30Z | https://github.com/chakra-core/ChakraCore/issues/2159 | 193,948,270 | 2,159 |
[
"chakra-core",
"ChakraCore"
] | The compiler we use in ChakraFull doesn't generate the same thing for mul/div with doubles as it does for ch.exe
The instruction set generated is
```asm
fld aLeft
fdiv/fmul aRight
```
The instructions we should use are
```asm
movsd xmm0, aLeft
divsd/mulsd xmm0, aRight
```
After fixing this, need to re-enable tests
test\WasmSpec\testsuite\float_misc.wast:313-317,404-409 | WASM - f64.mul/div interpreter precision on x86 | https://api.github.com/repos/chakra-core/ChakraCore/issues/2145/comments | 0 | 2016-12-06T00:53:18Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/2145 | 193,653,964 | 2,145 |
[
"chakra-core",
"ChakraCore"
] | Add a test run with -nonative on wasm spec tests | WASM - Spec tests with nonative | https://api.github.com/repos/chakra-core/ChakraCore/issues/2142/comments | 0 | 2016-12-05T21:10:10Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/2142 | 193,610,848 | 2,142 |
[
"chakra-core",
"ChakraCore"
] | When executing JS script on Linux we get an error saying "SyntaxError: Invalid character"
Script|Succeeds|comment
---|---|---
$global.data[1];|false|Seems to fail due to semicolon|
$global.data[1]|true|Succeeds without semicolon|
function foo(){ var a = [true,false]; return a; } |true|
function foo(){ var a = [1,2]; return a; }|true|This works, but when it comes to an objects array it again raises an error
function foo(){ var a = [{'b': true}, {'b': false}]; return a; }|false|Again with missing semicolon its working
function foo(){ var a = [{'b': true}, {'b': false}]; return a }|true|this only happens when using an object array
Basically we are using native method: JsRunScriptUtf8 to execute scripts above. Can you please give me a hint what we are doing wrong, since its seems to be a pretty weird. All scripts mentioned do not raise any error when running them on windows machines.
In addtion to that can you please provide in more detailed example on how to get to the exact error from the engine. I already made it to get the error message but the line and column number would be great to include into the error.
Thanks in advance. | Syntax Error on Ubuntu v. 16 (ChakraCore v. 1.3.1) | https://api.github.com/repos/chakra-core/ChakraCore/issues/2141/comments | 3 | 2016-12-05T15:00:01Z | 2016-12-06T15:24:55Z | https://github.com/chakra-core/ChakraCore/issues/2141 | 193,520,456 | 2,141 |
[
"chakra-core",
"ChakraCore"
] | As a JIT, ChakraCore has its own allocator for executable machine code. This is a feature request to expose this to embedders. | Feature request: Expose ChakraCore machine code allocator via JSRT | https://api.github.com/repos/chakra-core/ChakraCore/issues/2139/comments | 1 | 2016-12-04T01:35:38Z | 2018-02-22T00:19:16Z | https://github.com/chakra-core/ChakraCore/issues/2139 | 193,325,437 | 2,139 |
[
"chakra-core",
"ChakraCore"
] | New xplat CI found that `test/typedarray/samethread.js` fails after #2016 is being merged.
Repro: (on any distro or osx)
- Build [test-build]
- `test/runtests.py -t --include-slow test/typedarray`
Assigning this to @ianwjhalliday as [#2016] PR is the reason. | SlowTest-Fail: typedarray/samethread.js fails after #2016 | https://api.github.com/repos/chakra-core/ChakraCore/issues/2135/comments | 2 | 2016-12-02T00:40:11Z | 2016-12-17T02:00:35Z | https://github.com/chakra-core/ChakraCore/issues/2135 | 193,003,261 | 2,135 |
[
"chakra-core",
"ChakraCore"
] | The C++ compiler in x86 generates fstp instruction for float return values. This instruction changes the bit pattern of signaling float NaN (For example: from 0x7f80f1e2 to 0x7fc0f1e2). This is problematic in Wasm, as it relies on NaN bit patterns. In x86 debug all signaling NaNs will be canonicalized and we see uniform behavior. In x86 test however, due to optimizations, fstp instruction can get optimized away, and we see different bit patterns for signaling NaNs. | Wasm: Inconsistent representation of signalling NaNs in x86 test | https://api.github.com/repos/chakra-core/ChakraCore/issues/2125/comments | 0 | 2016-11-30T17:59:21Z | 2017-08-17T00:49:09Z | https://github.com/chakra-core/ChakraCore/issues/2125 | 192,636,209 | 2,125 |
[
"chakra-core",
"ChakraCore"
] | This character was recategorized from Zs to Cf in Unicode 6.3, and remains categorized as such in Unicode 9.0 (current target version). The current version of ECMAScript requires that only characters classed as Zs in the target version of Unicode be recognized as Whitespace. This change is now reflected in Test262 so making this change will improve our Test262 score rather than regress it.
See: https://github.com/tc39/ecma262/pull/300
See: https://github.com/tc39/test262/commit/3a5a09eba2adb6a8c24cf6e603aefe9bfa8d75b9
See: https://github.com/mathiasbynens/regexpu-core/commit/9b10d2a597d4e56b236cae0f9aa2f21a9c6d1122
Discovered while working on #1181 | [RegExp] Remove U+180E MONGOLIAN VOWEL SEPARATOR from Whitespace classification. | https://api.github.com/repos/chakra-core/ChakraCore/issues/2120/comments | 0 | 2016-11-30T03:35:34Z | 2016-12-07T00:51:24Z | https://github.com/chakra-core/ChakraCore/issues/2120 | 192,467,147 | 2,120 |
[
"chakra-core",
"ChakraCore"
] | The parser for legacy reasons allows parenthesized label names. ECMA262 spec doesn't allow this in the grammar nor in Annex B. Likewise, Chrome and many other JavaScript parsers do not recognize it.
This appears to be an old IE specific behavior, and changing it in Chakra is highly unlikely to break the web. Could have potentially have impact on WWAs. Therefore fix post 2.0.
E.g.
```javascript
function foo() {
((a)):
while (false) { }
}
```
This parses but shouldn't. `test/Basics/label1.js` captures this behavior.
Related PR #2115 | Remove parser allowance of parenthesized label names | https://api.github.com/repos/chakra-core/ChakraCore/issues/2119/comments | 0 | 2016-11-30T01:05:25Z | 2017-12-05T02:31:20Z | https://github.com/chakra-core/ChakraCore/issues/2119 | 192,447,405 | 2,119 |
[
"chakra-core",
"ChakraCore"
] | I'm using the master branch + PR #2056, latest of a few moments ago.
The following methods seem to be missing from both 'nix and macOS:
- JsInitializeModuleRecord
- JsSetModuleHostInfo
- JsParseModuleSource
- JsModuleEvaluation
The following tests are passing in windows, but failing on ubuntu/osx CI builds:
Windows (Passing):
https://ci.appveyor.com/project/Oceanswave/baristacore/build/1.0.39
Linux/OSx (Failing):
https://travis-ci.org/BaristaLabs/BaristaCore/builds/179819739
| xplat: Missing ES6 Module functionality in Linux and macOS | https://api.github.com/repos/chakra-core/ChakraCore/issues/2112/comments | 7 | 2016-11-29T19:32:34Z | 2017-01-11T15:38:55Z | https://github.com/chakra-core/ChakraCore/issues/2112 | 192,377,129 | 2,112 |
[
"chakra-core",
"ChakraCore"
] | Exported Functions also have the following data properties: the length property is set to the exported function's signature's arity
the name is set to index as a Number value
Depends on #2452 | WASM - exported function properties (4d) | https://api.github.com/repos/chakra-core/ChakraCore/issues/2101/comments | 0 | 2016-11-28T20:21:10Z | 2017-09-19T22:59:29Z | https://github.com/chakra-core/ChakraCore/issues/2101 | 192,107,401 | 2,101 |
[
"chakra-core",
"ChakraCore"
] | Both the in-solution build in react-native-windows and from the Developer Command Prompt for VS2017 RC, I get this message:
1> "C:\Users\matt.hargett\Source\Repos\rnw-mh\ChakraCore\Build\Chakra.Core.sln" (Core\Bin\ChakraCore target) (1) ->
1> "C:\Users\matt.hargett\Source\Repos\rnw-mh\ChakraCore\Build\..\bin\ChakraCore\ChakraCore.vcxproj.metaproj" (default target) (2) ->
1> "C:\Users\matt.hargett\Source\Repos\rnw-mh\ChakraCore\lib\common\util\Chakra.Common.Util.vcxproj" (default target) (16) ->
1>C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\VC\VCTargets\Microsoft.Cpp.Platform.targets(55,5): error MSB8020: The build tools for Visual Studio 2010 (Platform Toolset = 'v100') cannot be found. To build using the v100 build tools, please install Visual Studio 2010 build tools. Alternatively, you may upgrade to the current Visual Studio tools by selecting the Project menu or right-click the solution, and then selecting "Retarget solution". [C:\Users\matt.hargett\Source\Repos\rnw-mh\ChakraCore\lib\common\util\Chakra.Common.Util.vcxproj]
1> | neither master nor release/2.0-pre build with VS2017 RC | https://api.github.com/repos/chakra-core/ChakraCore/issues/2096/comments | 4 | 2016-11-27T04:34:07Z | 2017-05-31T18:24:14Z | https://github.com/chakra-core/ChakraCore/issues/2096 | 191,841,870 | 2,096 |
[
"chakra-core",
"ChakraCore"
] | I've executed the following code both with JSRT Legacy (jscript9.dll) and with the release version 1.3.0 of ChakraCore and have received very different results.
In case of version 1.3.0 the code has successfully completed.
In case of JSRT Legacy the code has thrown an exception of type `JavaScriptUsageException` with a message "Invalid argument." on the invocation of `obj.GetProperty`.
```c#
using (var runtime = JavaScriptRuntime.Create())
{
JavaScriptValue obj;
var context1 = runtime.CreateContext();
var context2 = runtime.CreateContext();
using (new JavaScriptContext.Scope(context1))
{
obj = JavaScriptValue.CreateObject();
var propId = JavaScriptPropertyId.FromString("prop");
obj.SetProperty(propId, JavaScriptValue.True, true);
}
using (new JavaScriptContext.Scope(context2))
{
var propId = JavaScriptPropertyId.FromString("prop");
var v = obj.GetProperty(propId); // <- this fails in JSRT Legacy
}
}
```
So I have a question: What is the intended behavior and which version of JSRT has a bug?
In other words: must the execution contexts be isolated or not?
| Isolation of Execution Contexts | https://api.github.com/repos/chakra-core/ChakraCore/issues/2092/comments | 4 | 2016-11-24T22:43:21Z | 2017-03-04T02:59:03Z | https://github.com/chakra-core/ChakraCore/issues/2092 | 191,599,124 | 2,092 |
[
"chakra-core",
"ChakraCore"
] | Open the developer console for logs.
Call Object.freeze on an array and set an element outside of the array's bounds.
Expected result: An exception is thrown
Actual result: No exception is thrown
This does not repro when setting elements inside the bounds of the array.
'use strict';
var arr = ["one", "two", "three"];
Object.freeze(arr);
console.log("Initial arr.length: " + arr.length);
try {
console.log("Setting arr[0]...");
arr[0] = "";
console.log("No exception thrown when setting arr[0]");
}
catch(e) {
console.log("Exception thrown when setting arr[0]");
}
console.log("arr[0] after setting - Expected: one, Actual: " + arr[0]);
console.log("arr.length: " + arr.length);
console.log();
try {
console.log("Setting arr[5]...");
arr[5] = "";
console.log("No exception thrown when setting arr[5]");
}
catch(e) {
console.log("Exception thrown when setting arr[5]");
}
console.log("arr[5] after setting - Expected: undefined, Actual: " + arr[5]);
console.log("arr.length: " + arr.length);
| Setting an element outside the bounds of a frozen array does not throw an exception | https://api.github.com/repos/chakra-core/ChakraCore/issues/2083/comments | 2 | 2016-11-23T01:46:55Z | 2016-12-17T09:31:47Z | https://github.com/chakra-core/ChakraCore/issues/2083 | 191,170,914 | 2,083 |
[
"chakra-core",
"ChakraCore"
] | Currently, when we handle "var x = new Array()", we allocate space for additional profile information on the array creation site. This allows us to do some optimizations and create native arrays, which are significantly faster in many cases. However, we can't currently do this for "var x = Array()". We had an attempt at doing this removed in https://github.com/Microsoft/ChakraCore/commit/db90b50c1bf606eef136274f19a9cf7fee2cd2ae, because it caused issues with the temporary register allocation in some situations (and likely produced incorrect code in some others). Doing this should win a good bit on minified code, as many minifiers remove the "new" from array creation sites to save 4 characters. | Create native arrays for bare Array() calls | https://api.github.com/repos/chakra-core/ChakraCore/issues/2082/comments | 4 | 2016-11-22T19:34:25Z | 2019-06-07T19:11:16Z | https://github.com/chakra-core/ChakraCore/issues/2082 | 191,103,154 | 2,082 |
[
"chakra-core",
"ChakraCore"
] | We have compile time problems with Clang 4.0 and keeping this issue in order to track that. | clang 4.0: fix build issues | https://api.github.com/repos/chakra-core/ChakraCore/issues/2080/comments | 1 | 2016-11-22T17:56:43Z | 2017-03-10T08:28:16Z | https://github.com/chakra-core/ChakraCore/issues/2080 | 191,079,940 | 2,080 |
[
"chakra-core",
"ChakraCore"
] | Our libunwind usage is very limited (PAL) and we don't actually expect SEH support on xplat.
| xplat: Remove libunwind dependency | https://api.github.com/repos/chakra-core/ChakraCore/issues/2079/comments | 1 | 2016-11-22T17:55:27Z | 2016-12-14T05:30:37Z | https://github.com/chakra-core/ChakraCore/issues/2079 | 191,079,626 | 2,079 |
[
"chakra-core",
"ChakraCore"
] | For every helper call to throw in jit, we spill the register to save them. This is not necessary as we never come back from the helper | Spilling caller save register on helper call that always throws (3d) | https://api.github.com/repos/chakra-core/ChakraCore/issues/2075/comments | 1 | 2016-11-21T23:30:56Z | 2017-05-18T18:18:26Z | https://github.com/chakra-core/ChakraCore/issues/2075 | 190,866,332 | 2,075 |
[
"chakra-core",
"ChakraCore"
] | We brought back custom `JsUtil::QuickSort` in swb branch to solve the problem that system qsort routine does not update write barrier when array element contains WriteBarrierPtr fields.
We need to fine tune `JsUtil::QuickSort` performance. Current implementation does not work well with already sorted or many equal items array.
Moreover, @obastemur said xplat `qsort_r` is not reliable on some platforms (#2069). We might prefer custom reliable implementation on xplat too. | swb: tune JsUtil::QuickSort implementation | https://api.github.com/repos/chakra-core/ChakraCore/issues/2074/comments | 2 | 2016-11-21T19:49:15Z | 2017-02-23T17:11:33Z | https://github.com/chakra-core/ChakraCore/issues/2074 | 190,817,595 | 2,074 |
[
"chakra-core",
"ChakraCore"
] | I created a object A, and added some member.
JsCreateObject
created external object B, and set prototype with A. C is finalizeCallback.
JsCreateExternalObject, JsSetPrototype
do gc.
JsCollectGarbage
why not call finalizeCallback C?
I tryed to call JsRelease(B, count) too, count is return (uint)-1, but useless.
| About JsObject's reference and release | https://api.github.com/repos/chakra-core/ChakraCore/issues/2072/comments | 5 | 2016-11-21T15:49:08Z | 2016-11-29T01:31:18Z | https://github.com/chakra-core/ChakraCore/issues/2072 | 190,755,203 | 2,072 |
[
"chakra-core",
"ChakraCore"
] | Some of our `debug` related tests provide fake filenames for scripts.
For example;
```
var x = WScript.LoadScript("function foo(){}", "samethread", "dummyFileName.js");
```
In case the `dummyFileName.js` is not exist on the actual folder, this particular call returns `undefined` back to JS land.
Expected behavior is given below;
Get current full path => join full path with this fake name => wholeName.toLowerCase => use the resulting string as a filename to run script. In other words, do not fail script run. | ch: LoadScript with fake script filename fails on xplat | https://api.github.com/repos/chakra-core/ChakraCore/issues/2065/comments | 1 | 2016-11-19T14:18:55Z | 2017-01-11T15:39:26Z | https://github.com/chakra-core/ChakraCore/issues/2065 | 190,498,658 | 2,065 |
[
"chakra-core",
"ChakraCore"
] | Opening this issue to track disabled test cases
`DebuggerCommon/TypedArray.js`
```
* thread #1: tid = 79144, 0x0000555555923a4b ch`Js::Amd64StackFrame::Next() + 11, name = 'ch', stop reason = signal SIGSEGV: invalid address (fault address: 0x9)
frame #0: 0x0000555555923a4b ch`Js::Amd64StackFrame::Next() + 11
ch`Js::Amd64StackFrame::Next:
-> 0x555555923a4b <+11>: movq 0x8(%rax), %rcx
0x555555923a4f <+15>: movq %rcx, 0x8(%rdi)
0x555555923a53 <+19>: movq (%rax), %rax
0x555555923a56 <+22>: movq %rax, (%rdi)
(lldb) bt
* thread #1: tid = 79144, 0x0000555555923a4b ch`Js::Amd64StackFrame::Next() + 11, name = 'ch', stop reason = signal SIGSEGV: invalid address (fault address: 0x9)
* frame #0: 0x0000555555923a4b ch`Js::Amd64StackFrame::Next() + 11
frame #1: 0x00005555559149c6 ch`Js::JavascriptStackWalker::Walk(bool) + 118
frame #2: 0x00005555559160fb ch`Js::JavascriptStackWalker::GetCaller(Js::JavascriptFunction**, bool) + 43
frame #3: 0x00005555557fb183 ch`Js::ProbeContainer::UpdateFramePointers(bool, unsigned long) + 1235
frame #4: 0x00005555557fb38a ch`Js::ProbeContainer::InitializeLocation(Js::InterpreterHaltState*, bool) + 74
frame #5: 0x00005555557fbeb7 ch`Js::ProbeContainer::DispatchProbeHandlers(Js::InterpreterHaltState*) + 135
frame #6: 0x00005555558764f8 ch`Js::InterpreterStackFrame::ProcessWithDebugging() + 840
frame #7: 0x0000555555870d78 ch`Js::InterpreterStackFrame::DebugProcess() + 120
```
`DebuggerCommon/attachdetach-delaycapture.js` fails similarly | xplat-debugger: DebuggerCommon test fails [JIT] [test] | https://api.github.com/repos/chakra-core/ChakraCore/issues/2064/comments | 0 | 2016-11-19T14:03:18Z | 2018-02-09T23:49:29Z | https://github.com/chakra-core/ChakraCore/issues/2064 | 190,498,020 | 2,064 |
[
"chakra-core",
"ChakraCore"
] | In https://github.com/Microsoft/ChakraCore/commit/57962d5ebc8640a9f86294d602a69bcd0053cd13 I had to disable an optimization to elevate BailOnNoProfile instructions, because we do not have accurate enough data for operand fgPeepTmp properties. Fixing the propagation of these values should allow re-enabling this optimization and getting a decent performance win in some minified code cases. | Fix fgPeepTmp annotation and re-enable related BailOnNoProfile Optimization | https://api.github.com/repos/chakra-core/ChakraCore/issues/2062/comments | 2 | 2016-11-19T03:26:01Z | 2019-06-07T19:11:20Z | https://github.com/chakra-core/ChakraCore/issues/2062 | 190,473,492 | 2,062 |
[
"chakra-core",
"ChakraCore"
] | Building ChakraCore on OSx 10.12.1 from master with latest using
``` bash
./build.sh --icu=/usr/local/opt/icu4c/include -j=4
```
When running ```nm -g libChakraCore.dylib``` on the resulting library, I see the JsTDDxxx symbols exported but not methods such as JsDiagStartDebugging as found on the Windows API.
Is there a way to start debugging on OSx?
OSx Symbols from libChakraCore.dylib:
```
0000000000053240 T _JsAddRef
0000000000054330 T _JsBoolToBoolean
00000000000545c0 T _JsBooleanToBool
000000000005cf40 T _JsCallFunction
0000000000052fb0 T _JsCollectGarbage
000000000005d4c0 T _JsConstructObject
0000000000054630 T _JsConvertValueToBoolean
0000000000054d60 T _JsConvertValueToNumber
0000000000056080 T _JsConvertValueToObject
0000000000055560 T _JsConvertValueToString
0000000000065310 T _JsCopyPropertyIdUtf8
0000000000064960 T _JsCopyString
0000000000064a30 T _JsCopyStringUtf16
0000000000064af0 T _JsCopyStringUtf8
0000000000059660 T _JsCreateArray
0000000000059910 T _JsCreateArrayBuffer
0000000000053a30 T _JsCreateContext
000000000005a410 T _JsCreateDataView
000000000005e160 T _JsCreateError
0000000000059c50 T _JsCreateExternalArrayBuffer
0000000000055c50 T _JsCreateExternalObject
000000000005d9b0 T _JsCreateFunction
000000000005dd20 T _JsCreateNamedFunction
00000000000559c0 T _JsCreateObject
0000000000065250 T _JsCreatePropertyIdUtf8
000000000005e530 T _JsCreateRangeError
000000000005e900 T _JsCreateReferenceError
0000000000052f40 T _JsCreateRuntime
00000000000646b0 T _JsCreateString
0000000000064940 T _JsCreateStringUtf16
0000000000064880 T _JsCreateStringUtf8
000000000005aa80 T _JsCreateSymbol
000000000005ecd0 T _JsCreateSyntaxError
000000000005f0a0 T _JsCreateTypeError
0000000000059f30 T _JsCreateTypedArray
000000000005f470 T _JsCreateURIError
00000000000591b0 T _JsDefineProperty
000000000005ba80 T _JsDeleteIndexedProperty
0000000000058da0 T _JsDeleteProperty
0000000000060010 T _JsDisableRuntimeExecution
0000000000052fe0 T _JsDisposeRuntime
0000000000054c00 T _JsDoubleToNumber
0000000000060080 T _JsEnableRuntimeExecution
000000000005c660 T _JsEquals
000000000005f8e0 T _JsGetAndClearException
000000000005a860 T _JsGetArrayBufferStorage
0000000000053e40 T _JsGetContextData
0000000000053df0 T _JsGetContextOfObject
0000000000053bb0 T _JsGetCurrentContext
000000000005aa10 T _JsGetDataViewStorage
0000000000056fc0 T _JsGetExtensionAllowed
000000000005ce90 T _JsGetExternalData
0000000000054260 T _JsGetFalseValue
0000000000055900 T _JsGetGlobalObject
000000000005c3a0 T _JsGetIndexedPropertiesExternalData
000000000005b1d0 T _JsGetIndexedProperty
00000000000540c0 T _JsGetNullValue
00000000000579d0 T _JsGetOwnPropertyDescriptor
0000000000057e30 T _JsGetOwnPropertyNames
00000000000581e0 T _JsGetOwnPropertySymbols
00000000000575e0 T _JsGetProperty
00000000000602e0 T _JsGetPropertyIdFromName
0000000000060530 T _JsGetPropertyIdFromSymbol
0000000000060a90 T _JsGetPropertyIdType
0000000000060a50 T _JsGetPropertyNameFromId
0000000000056420 T _JsGetPrototype
0000000000060ab0 T _JsGetRuntime
000000000005fe60 T _JsGetRuntimeMemoryLimit
000000000005fdd0 T _JsGetRuntimeMemoryUsage
0000000000055100 T _JsGetStringLength
0000000000060810 T _JsGetSymbolFromPropertyId
0000000000054190 T _JsGetTrueValue
000000000005a760 T _JsGetTypedArrayInfo
000000000005a8e0 T _JsGetTypedArrayStorage
0000000000053ff0 T _JsGetUndefinedValue
0000000000054a40 T _JsGetValueType
000000000005f840 T _JsHasException
000000000005ce60 T _JsHasExternalData
000000000005c2e0 T _JsHasIndexedPropertiesExternalData
000000000005ae30 T _JsHasIndexedProperty
00000000000589d0 T _JsHasProperty
0000000000060b00 T _JsIdle
0000000000056bb0 T _JsInstanceOf
0000000000054c60 T _JsIntToNumber
0000000000060290 T _JsIsRuntimeExecutionDisabled
0000000000054c90 T _JsNumberToDouble
0000000000054cf0 T _JsNumberToInt
0000000000064e50 T _JsParse
0000000000065520 T _JsParseSerialized
0000000000055150 T _JsPointerToString
00000000000572e0 T _JsPreventExtension
0000000000053530 T _JsRelease
0000000000065050 T _JsRun
0000000000065660 T _JsRunSerialized
0000000000065450 T _JsSerialize
0000000000062060 T _JsSerializeScript
0000000000053e80 T _JsSetContextData
0000000000053be0 T _JsSetCurrentContext
000000000005fa40 T _JsSetException
000000000005cef0 T _JsSetExternalData
000000000005bdf0 T _JsSetIndexedPropertiesToExternalData
000000000005b610 T _JsSetIndexedProperty
0000000000053820 T _JsSetObjectBeforeCollectCallback
0000000000060d60 T _JsSetPromiseContinuationCallback
0000000000058580 T _JsSetProperty
00000000000567c0 T _JsSetPrototype
000000000005ff10 T _JsSetRuntimeBeforeCollectCallback
000000000005feb0 T _JsSetRuntimeMemoryAllocationCallback
000000000005fe20 T _JsSetRuntimeMemoryLimit
000000000005ca60 T _JsStrictEquals
0000000000055420 T _JsStringToPointer
0000000000063d30 T _JsTTDCheckAndAssertIfTTDRunning
00000000000621a0 T _JsTTDCreateContext
00000000000620b0 T _JsTTDCreateRecordRuntime
0000000000062130 T _JsTTDCreateReplayRuntime
00000000000626c0 T _JsTTDEmitRecording
0000000000063e90 T _JsTTDGetPreviousSnapshotInterval
0000000000063e30 T _JsTTDGetSnapShotBoundInterval
0000000000063d70 T _JsTTDGetSnapTimeTopLevelEventMove
0000000000062bd0 T _JsTTDHostExit
0000000000064250 T _JsTTDMoveToTopLevelEvent
0000000000062320 T _JsTTDNotifyContextDestroy
00000000000629c0 T _JsTTDNotifyYield
0000000000062840 T _JsTTDPauseTimeTravelBeforeRuntimeOperation
00000000000640b0 T _JsTTDPreExecuteSnapShotInterval
0000000000063520 T _JsTTDRawBufferAsyncModificationRegister
00000000000639a0 T _JsTTDRawBufferAsyncModifyComplete
0000000000062eb0 T _JsTTDRawBufferCopySyncIndirect
0000000000063200 T _JsTTDRawBufferModifySyncIndirect
0000000000062900 T _JsTTDReStartTimeTravelAfterRuntimeOperation
0000000000064300 T _JsTTDReplayExecution
0000000000062360 T _JsTTDStart
0000000000062510 T _JsTTDStop
```
| xplat: ChakraDebug API missing from OSx build | https://api.github.com/repos/chakra-core/ChakraCore/issues/2058/comments | 4 | 2016-11-19T00:27:21Z | 2016-12-23T15:45:37Z | https://github.com/chakra-core/ChakraCore/issues/2058 | 190,453,345 | 2,058 |
[
"chakra-core",
"ChakraCore"
] | There are known optimizations on the table for async functions especially around avoiding object allocation. Our implementation of async functions is significantly slower than other implementations. V8 has [recently implemented](https://codereview.chromium.org/2512103002/) an optimization that I think we could apply as well.
Now that we've got async functions shipped and stable let's use this issue to track our optimization work. | Optimize async functions | https://api.github.com/repos/chakra-core/ChakraCore/issues/2055/comments | 1 | 2016-11-18T19:24:51Z | 2018-02-27T22:15:21Z | https://github.com/chakra-core/ChakraCore/issues/2055 | 190,400,924 | 2,055 |
[
"chakra-core",
"ChakraCore"
] | I have found that the Shared Debug library for linux does not work correctly. There is internal assert failures. The steps to reproduce are fairly straight forward if you follow the wiki with some slight changes( see: [Microsoft/ChakraCore Wiki: Embedding ChakraCore](https://github.com/Microsoft/ChakraCore/wiki/Embedding-ChakraCore)).
The steps to reproduce the issue are as follows...
1. Create a clean checkout of the Master ChakraCore branch.
2. Meet all build dependencies for ChakraCore. In my case I use Ubuntu 16.04 LTS with packaged versions of cmake, clang, ninja ( ninja-build package), and others.
3. Build chakracore debug library
```sh
# Run this in root directory for ChakraCore.
./build.sh -n -d
```
4. Wait for build to finish.
5. prepare an example runtime/link folder using above...
```sh
cd BuildLinux
mkdir DebugLibTest
cd DebugLibTest
# This command is for Linux.
cp ../Debug/libChakraCore.so .
# This is for OSX/Darwin.
#cp ../Debug/libChakraCore.dylib .
# add Headers.
mkdir include
cd include
# This will copy the four core headers outlined at...
# https://github.com/Microsoft/ChakraCore/wiki/Embedding-ChakraCore
cp ../../../lib/Jsrt/Chakra*.h .
```
6. Build an example... In this Case I use the Hello World example as the source... (see: https://github.com/Microsoft/Chakra-Samples/blob/master/ChakraCore%20Samples/Hello%20World/Linux_OSX/sample.cpp )
```sh
# NOTE: Copy sample.cpp from the Chakra Core Hello World example for Linux/OSX here.
# Build example on a Linux System...
clang++ sample.cpp $(pwd)/libChakraCore.so -Wl,-rpath,. -Iinclude -o Sample -std=c++11
# Build example on a OS X/Darwin System... - NOTE: I have not tested this.
# clang++ sample.cpp $(pwd)/libChakraCore.dylib -Wl,-rpath,. -Iinclude -o Sample -std=c++11
```
7. run the example.
```sh
./Sample
# This should output Hello World, but instead it crashes.
``` | Linux: Shared Debug Library Broken | https://api.github.com/repos/chakra-core/ChakraCore/issues/2052/comments | 1 | 2016-11-18T02:26:58Z | 2016-11-19T14:36:58Z | https://github.com/chakra-core/ChakraCore/issues/2052 | 190,220,347 | 2,052 |
[
"chakra-core",
"ChakraCore"
] | We use double to store all FloatConstOpnd's in JIT.
While building a NAN float32 constant in IRBuilder we call:
`IR::FloatConstOpnd::New(constVal, TyFloat32, m_func), m_func);`
The function is declared as :
`FloatConstOpnd *
FloatConstOpnd::New(FloatConstType value, IRType type, Func *func)`
where `FloatConstType` is double
The conversion instruction from float to double will turn a float 0x7fa00000 to 0x7fffc0000000 and then finally the value built will be 0x7fffc000.
This violates some tests in the spec. | WASM: float32 NAN value representation in JIT | https://api.github.com/repos/chakra-core/ChakraCore/issues/2049/comments | 3 | 2016-11-18T02:06:18Z | 2017-08-17T00:49:05Z | https://github.com/chakra-core/ChakraCore/issues/2049 | 190,217,734 | 2,049 |
[
"chakra-core",
"ChakraCore"
] | `(module (func (result i32)))` validates when it shouldn't | WASM - incorrectly validate function with return type with nothing in the type stack | https://api.github.com/repos/chakra-core/ChakraCore/issues/2048/comments | 5 | 2016-11-18T01:29:19Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/2048 | 190,213,072 | 2,048 |
[
"chakra-core",
"ChakraCore"
] | Implement LowererMD::IsOpndNegZero without a helper call | Lower IsOpndNegZero optimization (3d) | https://api.github.com/repos/chakra-core/ChakraCore/issues/2041/comments | 0 | 2016-11-17T21:20:29Z | 2017-05-04T22:45:58Z | https://github.com/chakra-core/ChakraCore/issues/2041 | 190,167,281 | 2,041 |
[
"chakra-core",
"ChakraCore"
] | This is sort of a big request, but fix compilation using GCC (version 5.4.0) on Ubuntu 16.04 LTS. Many Linux distributions use GCC as the default compiler.
| linux: Fix compile using GCC | https://api.github.com/repos/chakra-core/ChakraCore/issues/2038/comments | 9 | 2016-11-17T07:38:07Z | 2021-02-16T15:22:10Z | https://github.com/chakra-core/ChakraCore/issues/2038 | 189,964,287 | 2,038 |
[
"chakra-core",
"ChakraCore"
] | Add support to handle literals such as nan:0x0f1e2. The following tests for copysign and min/max are failing:
in `testsuite/float_misc.wast`
-noNative only:
(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2)
Both -noNative and forceNative:
(assert_return (invoke "f32.min" (f32.const 0.0) (f32.const nan:0x200000)) (f32.const nan:0x600000))
(assert_return (invoke "f32.min" (f32.const nan:0x200000) (f32.const 0.0)) (f32.const nan:0x600000))
(assert_return (invoke "f32.max" (f32.const nan:0x200000) (f32.const 0.0)) (f32.const nan:0x600000))
(assert_return (invoke "f64.min" (f64.const 0.0) (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
(assert_return (invoke "f64.min" (f64.const nan:0x4000000000000) (f64.const 0.0)) (f64.const nan:0xc000000000000))
(assert_return (invoke "f64.max" (f64.const 0.0) (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
(assert_return (invoke "f64.max" (f64.const nan:0x4000000000000) (f64.const 0.0)) (f64.const nan:0xc000000000000)
| WASM - handle float NAN literals | https://api.github.com/repos/chakra-core/ChakraCore/issues/2037/comments | 1 | 2016-11-17T05:57:23Z | 2017-08-17T00:49:13Z | https://github.com/chakra-core/ChakraCore/issues/2037 | 189,946,331 | 2,037 |
[
"chakra-core",
"ChakraCore"
] | Wrap WebAssembly Create in try/catch to catch WasmCompilationException and throw the proper javascript error | WASM - handle WasmCompilationException when instantiating | https://api.github.com/repos/chakra-core/ChakraCore/issues/2035/comments | 2 | 2016-11-17T02:33:50Z | 2017-02-01T00:56:05Z | https://github.com/chakra-core/ChakraCore/issues/2035 | 189,917,488 | 2,035 |
[
"chakra-core",
"ChakraCore"
] | WebAssembly.Module.imports resulting array should be in the same order as it was initially describe in the wasm section | WASM - WebAssembly.Module.imports keep order | https://api.github.com/repos/chakra-core/ChakraCore/issues/2034/comments | 0 | 2016-11-17T02:33:21Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/2034 | 189,917,404 | 2,034 |
[
"chakra-core",
"ChakraCore"
] | Fix WebAssembly.instantiate, Module.exports and Module.imports | WASM - js api bugs | https://api.github.com/repos/chakra-core/ChakraCore/issues/2033/comments | 0 | 2016-11-17T02:32:56Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/2033 | 189,917,334 | 2,033 |
[
"chakra-core",
"ChakraCore"
] | https://github.com/Microsoft/ChakraCore/wiki/Build-Status#legacy-builds
`
lib\Runtime\Library\WebAssemblyTable.cpp(124): error C2070: 'unknown': illegal sizeof operand [lib\Runtime\Library\Chakra.Runtime.Library.vcxproj]
`
`
lib\Runtime\Library\WebAssemblyTable.cpp(124): error C2338: sizeof(m_maxLength) == sizeof(uint32) [lib\Runtime\Library\Chakra.Runtime.Library.vcxproj]
` | [Legacy] Illegal argument to sizeof | https://api.github.com/repos/chakra-core/ChakraCore/issues/2026/comments | 2 | 2016-11-16T01:48:24Z | 2016-12-15T23:08:42Z | https://github.com/chakra-core/ChakraCore/issues/2026 | 189,559,666 | 2,026 |
[
"chakra-core",
"ChakraCore"
] | As I mentioned in commit 0f69cba81b8fed268d2b6ac73a786778d8075741 of PR #2016, the TypedArray tests are cumbersome to work with and contain a lot of redundancy. It would be great to consolidate them into a single test file using UTF.js and looping through the different TypedArray constructors instead of repeating tests for each explicity.
I found a couple bugs in these tests when I updated them. I suspect they may have more bugs, given their verbosity and sloppiness. | Clean up TypedArray tests (test/typedarray/*.js) | https://api.github.com/repos/chakra-core/ChakraCore/issues/2020/comments | 0 | 2016-11-15T19:49:36Z | 2018-02-27T22:17:26Z | https://github.com/chakra-core/ChakraCore/issues/2020 | 189,488,565 | 2,020 |
[
"chakra-core",
"ChakraCore"
] | Effectively, 'new Uint8Array(0)' and 'new Uint8Array()' and 'new Uint8Array(undefined)' should have the same behavior.
Converting from an internal issue.
This issue is not a spec deviation from ES 6.0. It's a spec change in ES 2017. In ES6, we were supposed to (and are correctly) throwing TypeError if length is undefined.
ES 6.0 spec text:
22.2.1.2 %TypedArray% ( length )
This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is not Object.
%TypedArray% called with argument length performs the following steps:
Assert: Type(length) is not Object.
1. If NewTarget is undefined, throw a TypeError exception.
1. If length is undefined, throw a TypeError exception.
1. Let numberLength be ToNumber(length).
1. Let elementLength be ToLength(numberLength).
1. ReturnIfAbrupt(elementLength).
1. If SameValueZero(numberLength, elementLength) is false, throw a RangeError exception.
1. Return AllocateTypedArray(NewTarget, elementLength).
Test case:
```js
new Uint8Array(0)
new Uint8Array()
new Uint8Array(undefined) // TypeError
``` | TypedArray constructor throws TypeError for undefined argument | https://api.github.com/repos/chakra-core/ChakraCore/issues/2014/comments | 2 | 2016-11-15T01:32:38Z | 2016-11-17T19:37:55Z | https://github.com/chakra-core/ChakraCore/issues/2014 | 189,275,384 | 2,014 |
[
"chakra-core",
"ChakraCore"
] | The Error/stack.js test fails because all the "finally" blocks are not executed (as of git master bbf46243132). I can reduce the issue to just this code
```javascript
try {
try {
throw 42;
} finally {
print("In finally");
}
}
catch (e) {
print("In catch", e.description);
}
```
If the test is run with -forceNative we get:
localhost:\~/git/ChakraCore%/home/xan/git/ChakraCore/BuildLinux/Test/ch -forceNative foo.js
In catch undefined
Without:
localhost:\~/git/ChakraCore%/home/xan/git/ChakraCore/BuildLinux/Test/ch foo.js
In finally
In catch undefined
The tests expect the latter behavior.
| jit: finally block is not executed after try/catch throws exception | https://api.github.com/repos/chakra-core/ChakraCore/issues/2009/comments | 15 | 2016-11-14T18:44:13Z | 2017-01-05T08:08:28Z | https://github.com/chakra-core/ChakraCore/issues/2009 | 189,191,809 | 2,009 |
[
"chakra-core",
"ChakraCore"
] | JsRunScriptUtf8 is missing from the Master branch, which is used in all of the samples for Linux. I guess previously there was a Linux branch and currently it's not there.
Could you please add this? or change the example program to use current exposed API? | JsRunScriptUtf8 missing | https://api.github.com/repos/chakra-core/ChakraCore/issues/2006/comments | 4 | 2016-11-14T14:19:25Z | 2016-11-15T09:24:28Z | https://github.com/chakra-core/ChakraCore/issues/2006 | 189,123,330 | 2,006 |
[
"chakra-core",
"ChakraCore"
] | I see the same source file I had cleaned up from white spaces is now with of new whitespaces.
It is really hard to see what was changed with the commit due to white-space noise.
We might introduce `git diff --check` or something similar to limit whitespace noise.
| Introduce git diff --check or something similar | https://api.github.com/repos/chakra-core/ChakraCore/issues/2004/comments | 27 | 2016-11-14T12:15:23Z | 2017-03-10T08:20:22Z | https://github.com/chakra-core/ChakraCore/issues/2004 | 189,098,046 | 2,004 |
[
"chakra-core",
"ChakraCore"
] | We could have `test flag` options are available to our xplat `ch` release.
I don't see any reason to include `debug dump` related functionality to that binary. My intention is to support test flags without hurting the performance of the binary.
Looked through the source codes and saw `ENABLE_DEBUG_CONFIG_OPTIONS` is used in many places where `DBG_DUMP` or others are more suitable.
I'm not proposing a change to our `test` builds or current release builds. However, we could have something in the middle.
Opinions? | Fix ENABLE_DEBUG_CONFIG_OPTIONS usage | https://api.github.com/repos/chakra-core/ChakraCore/issues/2003/comments | 1 | 2016-11-14T09:42:17Z | 2017-09-13T01:08:47Z | https://github.com/chakra-core/ChakraCore/issues/2003 | 189,067,284 | 2,003 |
[
"chakra-core",
"ChakraCore"
] | I see that the latest JSRT code ``master`` branch has a different API than what is documented in the [wiki](https://github.com/Microsoft/ChakraCore/wiki/JavaScript-Runtime-%28JSRT%29-Reference). Notably ``JsStringToPointer()`` no longer exist but there are functions like ``JsCopyString()`` which use utf-8 instead. This is really great but I cannot find documentation anywhere.
Could you either point me to the documentation or instructions on how to build the API docs from the source? | New JSRT API documentation | https://api.github.com/repos/chakra-core/ChakraCore/issues/2002/comments | 5 | 2016-11-14T01:10:17Z | 2016-11-16T01:43:26Z | https://github.com/chakra-core/ChakraCore/issues/2002 | 189,009,541 | 2,002 |
[
"chakra-core",
"ChakraCore"
] | Make imported int64 globals throw at instantiation time instead of compile time | WASM - Int64 imported global error | https://api.github.com/repos/chakra-core/ChakraCore/issues/1996/comments | 0 | 2016-11-12T01:12:23Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/1996 | 188,882,684 | 1,996 |
[
"chakra-core",
"ChakraCore"
] | Known place that needs updating
- LowererMDArch::LowerWasmMemOp
- trunc and div/rem | WASM - Use WebAssembly.RuntimeError where needed | https://api.github.com/repos/chakra-core/ChakraCore/issues/1991/comments | 0 | 2016-11-11T22:10:18Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/1991 | 188,862,096 | 1,991 |
[
"chakra-core",
"ChakraCore"
] | Getting this in debug builds with clang 3.9.1:
/home/xan/git/ChakraCore/lib/Runtime/ByteCode/ByteCodeDumper.cpp:1192:21: error: definition with same mangled name as another definition
ByteCodeDumper::DumpReg2(OpCode op, const unaligned T * data, FunctionBody * dumpFunction, ByteCodeReader& reader)
^
/home/xan/git/ChakraCore/lib/Runtime/ByteCode/LayoutTypes.h:47:1: note: previous definition is here
LAYOUT_TYPE_PROFILED_WMS (Reg2)
^
/home/xan/git/ChakraCore/lib/Runtime/./ByteCode/ByteCodeDumper.h:57:9: note: expanded from macro 'LAYOUT_TYPE_PROFILED_WMS'
LAYOUT_TYPE_WMS(layout) \
^
/home/xan/git/ChakraCore/lib/Runtime/./ByteCode/ByteCodeDumper.h:36:36: note: expanded from macro 'LAYOUT_TYPE_WMS'
template <class T> static void Dump##layout(OpCode op, const unaligned T* data, FunctionBody * dumpFunction, ByteCodeReader& reader);
^
<scratch space>:117:1: note: expanded from here
DumpReg2
^
If I understand this right the collision seems to be between the methods in ByteCodeDumper and the static methods generated by the macros in the header, which apparently end up having the same mangled name and make clang unhappy. | Mangled name collision with clang 3.9.1 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1989/comments | 1 | 2016-11-11T19:33:39Z | 2016-11-14T21:18:12Z | https://github.com/chakra-core/ChakraCore/issues/1989 | 188,833,400 | 1,989 |
[
"chakra-core",
"ChakraCore"
] | I have a page (parent.html) that opens another page (child.html) in a new window. That child page calls a function that was defined globally in its opener, passing in an array. In that function, a new Set is created, passing the array received from the child window to the Set constructor. This leads to the error "SCRIPT5002: Function expected" on the console, pointing to the beginning of the line where the Set constructor is called.
In Chrome and Firefox this works. In IE11 it probably doesn't throw this error because Set doesn't support putting a collection into the constructor.
I assume the problem is that the array has the prototype from the child window and is therefore not compatible with what the Set constructor expects. The error can be circumvented by wrapping the array in an Array.from() call before passing it to the Set constructor, thus first creating an array that is compatible with the execution context of the parent window. My worry is that this leads to unnecessary memory consumption though (in my original page I pass very large arrays between the windows).
This happens when I open the files from a webserver (both pages on the same domain), I haven't tried it from the local file system.
The code to reproduce this is as follows:
parent.html:
```
<!DOCTYPE html>
<html>
<head></head>
<body>
<script>
window.myFunction = function(array) {
var set = new Set(array);
console.log(set);
};
window.open("child.html", "dialog", 'toolbar=no, location=no, status=no, scrollbars=no, menubar=no, resizable=yes, width=100, height=100');
</script>
</body>
</html>
```
child.html:
```
<!DOCTYPE html>
<html>
<head></head>
<body>
<button type="button" id="button">Click me!</button>
<script>
document.getElementById("button").addEventListener("click", function() {
window.opener.myFunction([0, 1, 2]);
}, false);
</script>
</body>
</html>
``` | "SCRIPT5002: Function expected" when passing array from other window to Set constructor | https://api.github.com/repos/chakra-core/ChakraCore/issues/1987/comments | 4 | 2016-11-11T14:18:16Z | 2016-11-19T01:29:20Z | https://github.com/chakra-core/ChakraCore/issues/1987 | 188,769,341 | 1,987 |
[
"chakra-core",
"ChakraCore"
] | The following tests are failing in jitted code
`test/WasmSpec/testsuite/conversions.wast` lines 266 & 268
`test/WasmSpec/testsuite/float_exprs.wast` lines 493 & 698-700 | WASM - f32.convert_u/i32 bugs | https://api.github.com/repos/chakra-core/ChakraCore/issues/1967/comments | 5 | 2016-11-09T20:57:50Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/1967 | 188,350,702 | 1,967 |
[
"chakra-core",
"ChakraCore"
] | Wrong behavior in jitted code for i32.trunc_u/f32 and i32.trunc_u/f64
See test/WasmSpec/conversions.wast lines 78-84 and 117-122
test/WasmSpec/float_exprs.wast lines 695-696
test/WasmSpec/float_exprs.wast lines 704-709 | WASM - int32 trunc bug | https://api.github.com/repos/chakra-core/ChakraCore/issues/1957/comments | 6 | 2016-11-08T23:56:17Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/1957 | 188,136,701 | 1,957 |
[
"chakra-core",
"ChakraCore"
] | f32.min and f32.max invalid result with `-0` depending if it's the 1st or 2nd argument.
Also different behavior between interpreter and Jit.
See
test/WasmSpec/testsuite/f32.wast:1318
test/WasmSpec/testsuite/f32.wast:1642
test/WasmSpec/testsuite/f64.wast:1318
test/WasmSpec/testsuite/f64.wast:1643 | WASM - f32/f64.min/max -0 bug | https://api.github.com/repos/chakra-core/ChakraCore/issues/1954/comments | 1 | 2016-11-08T21:19:58Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/1954 | 188,106,221 | 1,954 |
[
"chakra-core",
"ChakraCore"
] | Implement i32.Wrap/i64 operator
C++ equivalent to `int32 result = (int32)someInt64Val;` | WASM - i32.Wrap/i64 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1946/comments | 1 | 2016-11-08T02:46:45Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/1946 | 187,887,967 | 1,946 |
[
"chakra-core",
"ChakraCore"
] | Proposed in #1802 | Use /Zc:strictStrings flag in VC builds. | https://api.github.com/repos/chakra-core/ChakraCore/issues/1942/comments | 3 | 2016-11-08T00:49:48Z | 2020-03-31T15:16:44Z | https://github.com/chakra-core/ChakraCore/issues/1942 | 187,872,145 | 1,942 |
[
"chakra-core",
"ChakraCore"
] | I've found that when saying `test Ubuntu ubuntu_linux_release_static`, both `ubuntu_linux_release_static` and `Ubuntu ubuntu_linux_release` get rerun. | dotnet-bot seems to test everything that has substring of your request | https://api.github.com/repos/chakra-core/ChakraCore/issues/1933/comments | 12 | 2016-11-07T19:23:33Z | 2017-03-02T11:41:34Z | https://github.com/chakra-core/ChakraCore/issues/1933 | 187,803,185 | 1,933 |
[
"chakra-core",
"ChakraCore"
] | Steps to reproduce
---
Execute build steps as documented here:
https://github.com/Microsoft/ChakraCore/wiki/Building-ChakraCore
Replacing
```
git checkout linux
```
with
```
git checkout release/1.3
```
Expected Behavior
---
Successful build of ChakraCore on macOS
Actual Behavior
---
The build fails with an error saying there's a call to a deprecated system call on macOS 10.12.
```
Scanning dependencies of target Chakra.Pal
[ 0%] Building CXX object pal/src/CMakeFiles/Chakra.Pal.dir/cruntime/file.cpp.o
[ 1%] Building CXX object pal/src/CMakeFiles/Chakra.Pal.dir/cruntime/filecrt.cpp.o
/ChakraCore/pal/src/cruntime/filecrt.cpp:355:12: error:
'syscall' is deprecated: first deprecated in macOS 10.12 - syscall(2) is
unsupported; please switch to a supported interface. For SYS_kdebug_trace
use kdebug_signpost(). [-Werror,-Wdeprecated-declarations]
nRet = syscall(SYS_delete, szPath);
^
/usr/include/unistd.h:733:6: note: 'syscall' has been explicitly marked
deprecated here
int syscall(int, ...);
^
1 error generated.
make[2]: *** [pal/src/CMakeFiles/Chakra.Pal.dir/cruntime/filecrt.cpp.o] Error 1
make[1]: *** [pal/src/CMakeFiles/Chakra.Pal.dir/all] Error 2
make: *** [all] Error 2
```
| Build on macOS 10.12 fails due to deprecated system call | https://api.github.com/repos/chakra-core/ChakraCore/issues/1927/comments | 1 | 2016-11-06T15:51:23Z | 2016-11-07T05:16:33Z | https://github.com/chakra-core/ChakraCore/issues/1927 | 187,569,420 | 1,927 |
[
"chakra-core",
"ChakraCore"
] | Hi,
We found an odd crash of the ChakraCore interpreter (ch) when you "throw a float". It was tested in ArchLinux using revision 627e01bc65455b2dad495bd311a2eced7417e97f.
To reproduce:
```
$ echo "throw 1.1;" > sigill.js
$ gdb --args ./ch sigill.js
...
Thread 1 "ch" received signal SIGILL, Illegal instruction.
0x00007ffff48832fd in Js::FDblToRgbFast (dbl=1.1000000000000001,
prgb=0x7fffffffd5a0 "\001\001\377\377\377\177", pwExp10=0x7fffffffd5e0, ppbLim=0x7fffffffd598,
nDigits=-1) at /home/g/Work/Code/ChakraCore/lib/Common/Common/NumberUtilities_strtod.cpp:1592
1592 if (wExp2 >= 1023 && wExp2 <= 1075 && dbl == floor(dbl))
(gdb) bt
#0 0x00007ffff48832fd in Js::FDblToRgbFast (dbl=1.1000000000000001,
prgb=0x7fffffffd5a0 "\001\001\377\377\377\177", pwExp10=0x7fffffffd5e0, ppbLim=0x7fffffffd598,
nDigits=-1) at /home/g/Work/Code/ChakraCore/lib/Common/Common/NumberUtilities_strtod.cpp:1592
#1 0x00007ffff4888483 in Js::NumberUtilities::FNonZeroFiniteDblToStr (dbl=1.1000000000000001,
pchDst=0x7fffffffd610 u"1.1", cchDst=256)
at /home/g/Work/Code/ChakraCore/lib/Common/Common/NumberUtilities_strtod.cpp:2452
#2 0x00007ffff51c14b1 in Js::JavascriptNumber::ToStringRadix10 (value=1.1000000000000001,
scriptContext=0x555555910d10)
at /home/g/Work/Code/ChakraCore/lib/Runtime/Library/JavascriptNumber.cpp:928
#3 0x00007ffff4eece7c in Js::JavascriptConversion::ToString (aValue=0xc00d99999999999a,
scriptContext=0x555555910d10)
at /home/g/Work/Code/ChakraCore/lib/Runtime/Language/JavascriptConversion.cpp:621
#4 0x00007ffff4424c17 in JsConvertValueToString::$_21::operator() (this=0x7fffffffdba8,
scriptContext=0x555555910d10) at /home/g/Work/Code/ChakraCore/lib/Jsrt/Jsrt.cpp:1139
#5 0x00007ffff440026a in ContextAPIWrapper<true, JsConvertValueToString::$_21> (fn=...)
at /home/g/Work/Code/ChakraCore/lib/Jsrt/JsrtInternal.h:139
#6 0x00007ffff440016d in JsConvertValueToString (value=0xc00d99999999999a, result=0x7fffffffdfd0)
at /home/g/Work/Code/ChakraCore/lib/Jsrt/Jsrt.cpp:1132
#7 0x00005555555685a8 in ChakraRTInterface::JsConvertValueToString (value=0xc00d99999999999a,
stringValue=0x7fffffffdfd0) at /home/g/Work/Code/ChakraCore/bin/ch/ChakraRtInterface.h:304
#8 0x000055555556e2cb in WScriptJsrt::PrintException (fileName=0x5555558db860 "sigill.js",
jsErrorCode=JsErrorScriptException) at /home/g/Work/Code/ChakraCore/bin/ch/WScriptJsrt.cpp:1006
#9 0x000055555555e34c in RunScript (fileName=0x5555558db860 "sigill.js",
fileContents=0x5555558cfc10 "throw 1.1;\n", bcBuffer=0x0,
---Type <return> to continue, or q <return> to quit---
fullPath=0x7fffffffe520 "/home/g/work/code/chakracore/buildlinux/debug/sigill.js")
at /home/g/Work/Code/ChakraCore/bin/ch/ch.cpp:342
#10 0x000055555555f4f6 in ExecuteTest (fileName=0x5555558db860 "sigill.js")
at /home/g/Work/Code/ChakraCore/bin/ch/ch.cpp:587
#11 0x000055555555f5e0 in ExecuteTestWithMemoryCheck (fileName=0x5555558db860 "sigill.js")
at /home/g/Work/Code/ChakraCore/bin/ch/ch.cpp:635
#12 0x000055555555fb20 in main (argc=2, c_argv=0x7fffffffe868)
at /home/g/Work/Code/ChakraCore/bin/ch/ch.cpp:862
```
This issue was found using QuickFuzz.
Regards,
Gustavo. | SIGILL when throwing an exception | https://api.github.com/repos/chakra-core/ChakraCore/issues/1922/comments | 6 | 2016-11-04T23:24:36Z | 2016-11-07T06:41:25Z | https://github.com/chakra-core/ChakraCore/issues/1922 | 187,459,010 | 1,922 |
[
"chakra-core",
"ChakraCore"
] | Some JSRT API accept `char` for Utf8 named functions while others `uint8_t`.
We had a small discussion on this. Shared my opinion below;
- `char` is more developer friendly and all C / IO comes with `char`.
If a developer has nothing to do with utf8 encoding / flags etc.
there is no reason for her/him to use `unsigned`. At least I can’t think of any.
- No matter what we choose for external type, internally we will continue using `unsigned`.
- Having `char` argument may make ASCII based string interface obsolete.
/cc @agarwal-sandeep @curtisman @jianchun @liminzhu | JSRT: uint8_t vs char for Utf8 interface | https://api.github.com/repos/chakra-core/ChakraCore/issues/1918/comments | 8 | 2016-11-04T05:22:05Z | 2016-12-27T18:34:23Z | https://github.com/chakra-core/ChakraCore/issues/1918 | 187,256,110 | 1,918 |
[
"chakra-core",
"ChakraCore"
] | Only few of our callbacks can execute JSRT API calls. i.e. new `JsSerializedLoadScriptCallback` is one of them. https://github.com/Microsoft/ChakraCore/blob/master/lib/Jsrt/JsrtSourceHolder.cpp#L246-L252
Is there any particular callback we shouldn't allow JSRT API calls ? or best if we make them all capable of doing this?
/cc @agarwal-sandeep @liminzhu | JSRT: Inconsistent Callback behavior | https://api.github.com/repos/chakra-core/ChakraCore/issues/1917/comments | 10 | 2016-11-04T05:09:33Z | 2018-03-17T01:27:04Z | https://github.com/chakra-core/ChakraCore/issues/1917 | 187,254,966 | 1,917 |
[
"chakra-core",
"ChakraCore"
] | The start function must not take any arguments | WASM - Validate Start Function | https://api.github.com/repos/chakra-core/ChakraCore/issues/1901/comments | 0 | 2016-11-02T01:45:49Z | 2016-12-20T00:33:05Z | https://github.com/chakra-core/ChakraCore/issues/1901 | 186,692,594 | 1,901 |
[
"chakra-core",
"ChakraCore"
] | For i64.div/rem add checks to handle DivideByZero, IntegerOverflow
| WASM - Int64 Math Traps | https://api.github.com/repos/chakra-core/ChakraCore/issues/1900/comments | 1 | 2016-11-02T00:11:46Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1900 | 186,681,790 | 1,900 |
[
"chakra-core",
"ChakraCore"
] | ```js
(function() {
var v = new Int8Array(2);
v[1] = 31;
Object.defineProperty(v, 'length', {value : 4});
var ret = v.toLocaleString()
console.log(ret);
})();
```
toLocaleString should iterate over the length we got from internal slot of typed array instead of Get('length')
Expected
```0.00, 31.00```
Actual
```0.00, 31.00, , ``` | TypedArray : toLocaleString should use length from internal slot | https://api.github.com/repos/chakra-core/ChakraCore/issues/1896/comments | 0 | 2016-11-01T21:16:37Z | 2016-12-22T02:12:50Z | https://github.com/chakra-core/ChakraCore/issues/1896 | 186,649,672 | 1,896 |
[
"chakra-core",
"ChakraCore"
] | When importing a WebAssembly function into another module, that function needs to be called without boxing/unboxing.
The main reason is to support types that are not supported by javascript.
The solution we came up with is to create a wasm thunk (similar to #1807) that will then call the import and put this in the function array of the module's environment.
If the function we import is a WebAssembly function, we will replace the thunk by that function.
Then all calls will be internal calls.
This also solves #1873
Depends on #1821
| WASM - Treat imported WebAssembly functions as internal functions | https://api.github.com/repos/chakra-core/ChakraCore/issues/1895/comments | 0 | 2016-11-01T20:44:21Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1895 | 186,641,942 | 1,895 |
[
"chakra-core",
"ChakraCore"
] | ```js
(function() {
var arr = [11, 22, 33, 44];
var first = true;
arr.reduce(function (a1, a2, a3, a4) {
if (first) {
first = false;
Object.defineProperty(arr, '2', { get : function() {
return 201;
}});
}
console.log(a2);
});
})();
```
This should print (Chrome and Firefox do that)
22
201
44
Actual
22
44
This is because we use the DirectGetItem to fetch values.
| Changing array to es5array on array method does not give correct output. | https://api.github.com/repos/chakra-core/ChakraCore/issues/1893/comments | 2 | 2016-11-01T18:17:41Z | 2017-02-04T01:52:26Z | https://github.com/chakra-core/ChakraCore/issues/1893 | 186,607,093 | 1,893 |
[
"chakra-core",
"ChakraCore"
] | Hi, what is the state of C# -> WASM toolchain using Microsoft tools such as Visual Studio? Thanks. | WASM - C# toolchain? | https://api.github.com/repos/chakra-core/ChakraCore/issues/1891/comments | 12 | 2016-11-01T09:53:36Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1891 | 186,496,049 | 1,891 |
[
"chakra-core",
"ChakraCore"
] | Related #1852
We want to calculate const math in the backend if possible.
Make sure the operators that differ from javascript are correctly handled | WASM - Fold const math operations (5d) | https://api.github.com/repos/chakra-core/ChakraCore/issues/1889/comments | 0 | 2016-10-31T22:37:13Z | 2017-05-04T01:14:52Z | https://github.com/chakra-core/ChakraCore/issues/1889 | 186,417,501 | 1,889 |
[
"chakra-core",
"ChakraCore"
] | Use the fast array implementation to detect out of bounds access and trap. | WASM - fast array out of bounds traps | https://api.github.com/repos/chakra-core/ChakraCore/issues/1888/comments | 0 | 2016-10-31T22:36:18Z | 2017-02-17T02:32:26Z | https://github.com/chakra-core/ChakraCore/issues/1888 | 186,417,331 | 1,888 |
[
"chakra-core",
"ChakraCore"
] | Add support for int64 and float32 arguments when calling imports
Depends on #1895 | WASM - Int64/Float32 support in call import | https://api.github.com/repos/chakra-core/ChakraCore/issues/1887/comments | 0 | 2016-10-31T22:35:31Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1887 | 186,417,211 | 1,887 |
[
"chakra-core",
"ChakraCore"
] | The following asserts at this time.
```js
print(Wasm.instantiateModule(buffer, ffi).exports.a);
```
Investigate and fix the bug | WASM - assert when printing functions | https://api.github.com/repos/chakra-core/ChakraCore/issues/1886/comments | 0 | 2016-10-31T22:34:46Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1886 | 186,417,096 | 1,886 |
[
"chakra-core",
"ChakraCore"
] | Setup tools to test and make sure the wasm frontend is secure | WASM - Security analysis (2w) | https://api.github.com/repos/chakra-core/ChakraCore/issues/1885/comments | 2 | 2016-10-31T22:33:56Z | 2017-05-03T23:19:26Z | https://github.com/chakra-core/ChakraCore/issues/1885 | 186,416,978 | 1,885 |
[
"chakra-core",
"ChakraCore"
] | Implement the final javascript API for the MVP | WASM - Async Javascript API | https://api.github.com/repos/chakra-core/ChakraCore/issues/1884/comments | 0 | 2016-10-31T22:32:48Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1884 | 186,416,794 | 1,884 |
[
"chakra-core",
"ChakraCore"
] | We won't support debugging right now, but we need to make sure we don't crash when opening the debugger. | WASM - Investigate Debugging/Profiling scenario on Edge | https://api.github.com/repos/chakra-core/ChakraCore/issues/1883/comments | 2 | 2016-10-31T22:32:02Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1883 | 186,416,578 | 1,883 |
[
"chakra-core",
"ChakraCore"
] | We should make a copy of the binary buffer and use this for compilation instead of the source.
The reason is the source can be modified between the time it is passed and when we do the actual compilation. | WASM - Copy binary buffer | https://api.github.com/repos/chakra-core/ChakraCore/issues/1882/comments | 1 | 2016-10-31T22:31:20Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1882 | 186,416,427 | 1,882 |
[
"chakra-core",
"ChakraCore"
] | Until we have debugging support, we should ignore that section. | WASM - Ignore names section | https://api.github.com/repos/chakra-core/ChakraCore/issues/1881/comments | 0 | 2016-10-31T22:30:09Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1881 | 186,416,221 | 1,881 |
[
"chakra-core",
"ChakraCore"
] | Trap on invalid indirect call (out of bounds and invalid signature) | WASM - Indirect call trap | https://api.github.com/repos/chakra-core/ChakraCore/issues/1879/comments | 0 | 2016-10-31T22:29:23Z | 2016-12-20T00:33:04Z | https://github.com/chakra-core/ChakraCore/issues/1879 | 186,416,094 | 1,879 |
[
"chakra-core",
"ChakraCore"
] | Verify and implement math operators that need to trap
https://github.com/WebAssembly/design/blob/binary_0xc/AstSemantics.md#32-bit-integer-operators | WASM - Int32 Math and conversion traps | https://api.github.com/repos/chakra-core/ChakraCore/issues/1878/comments | 8 | 2016-10-31T22:27:51Z | 2016-12-20T00:33:03Z | https://github.com/chakra-core/ChakraCore/issues/1878 | 186,415,815 | 1,878 |
[
"chakra-core",
"ChakraCore"
] | Throw trap when doing out of bounds access | WASM - Array access out of bounds | https://api.github.com/repos/chakra-core/ChakraCore/issues/1877/comments | 0 | 2016-10-31T22:27:11Z | 2016-12-20T00:33:03Z | https://github.com/chakra-core/ChakraCore/issues/1877 | 186,415,680 | 1,877 |
[
"chakra-core",
"ChakraCore"
] | Support exporting the table our of the wasm module
https://github.com/WebAssembly/design/blob/binary_0xc/BinaryEncoding.md#export-entry | WASM - Export Table | https://api.github.com/repos/chakra-core/ChakraCore/issues/1876/comments | 0 | 2016-10-31T22:26:23Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1876 | 186,415,538 | 1,876 |
[
"chakra-core",
"ChakraCore"
] | Support importing memory object to the wasm module
https://github.com/WebAssembly/design/blob/binary_0xc/BinaryEncoding.md#import-entry
| WASM - Import Memory | https://api.github.com/repos/chakra-core/ChakraCore/issues/1875/comments | 2 | 2016-10-31T22:25:55Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1875 | 186,415,441 | 1,875 |
[
"chakra-core",
"ChakraCore"
] | Support importing a table to the wasm module
depends on new Js API
https://github.com/WebAssembly/design/blob/binary_0xc/BinaryEncoding.md#import-entry | WASM - Import table | https://api.github.com/repos/chakra-core/ChakraCore/issues/1874/comments | 0 | 2016-10-31T22:25:26Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1874 | 186,415,360 | 1,874 |
[
"chakra-core",
"ChakraCore"
] | Correctly call imported functions from the function table (intermediary function used for the conversion) | WASM - Imported function in the table | https://api.github.com/repos/chakra-core/ChakraCore/issues/1873/comments | 1 | 2016-10-31T22:24:13Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1873 | 186,415,100 | 1,873 |
[
"chakra-core",
"ChakraCore"
] | Support globals to define the offset of the elements segment
https://github.com/WebAssembly/design/blob/binary_0xc/BinaryEncoding.md#element-section
| WASM - Elements segments Init Expression | https://api.github.com/repos/chakra-core/ChakraCore/issues/1872/comments | 0 | 2016-10-31T22:23:48Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1872 | 186,415,029 | 1,872 |
[
"chakra-core",
"ChakraCore"
] | Implement operator i64.reinterpret/f64 | WASM - i64.reinterpret/f64 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1871/comments | 0 | 2016-10-31T22:22:08Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1871 | 186,414,723 | 1,871 |
[
"chakra-core",
"ChakraCore"
] | Implement operator f64.reinterpret/i64 | WASM - f64.reinterpret/i64 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1870/comments | 0 | 2016-10-31T22:21:46Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1870 | 186,414,658 | 1,870 |
[
"chakra-core",
"ChakraCore"
] | Implement operator f64.convert_u/i64 | WASM - f64.convert_u/i64 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1869/comments | 0 | 2016-10-31T22:21:26Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1869 | 186,414,605 | 1,869 |
[
"chakra-core",
"ChakraCore"
] | Implement operator f64.convert_s/i64 | WASM - f64.convert_s/i64 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1868/comments | 0 | 2016-10-31T22:21:08Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1868 | 186,414,537 | 1,868 |
[
"chakra-core",
"ChakraCore"
] | Implement operator f32.convert_u/i64 | WASM - f32.convert_u/i64 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1867/comments | 0 | 2016-10-31T22:20:50Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1867 | 186,414,480 | 1,867 |
[
"chakra-core",
"ChakraCore"
] | Implement operator f32.convert_s/i64 | WASM - f32.convert_s/i64 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1866/comments | 0 | 2016-10-31T22:20:27Z | 2016-12-20T00:33:26Z | https://github.com/chakra-core/ChakraCore/issues/1866 | 186,414,403 | 1,866 |
[
"chakra-core",
"ChakraCore"
] | Implement operator i64.extend_u/i32 | WASM - i64.extend_u/i32 | https://api.github.com/repos/chakra-core/ChakraCore/issues/1865/comments | 1 | 2016-10-31T22:20:11Z | 2016-12-20T00:33:25Z | https://github.com/chakra-core/ChakraCore/issues/1865 | 186,414,358 | 1,865 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.