[debugger] Added debugger support for Zephyr

Created shim layer for building against the POSIX network stack on
Zephyr which enables the debugger to run on the frdm_k64f board with
TCP IPV4 on port 5001.

Signed-off-by: Jimmy Huang <jimmy.huang@intel.com>

Author: jimmy-huang

Makefile

@@ -10,6 +10,7 @@ OS := $(shell uname)
 
 BOARD ?= arduino_101
 
+SCRIPT_SIZE ?= 8192
 RAM ?= 64
 ROM ?= 144
 V ?= 0
@@ -37,9 +38,11 @@ $(error ZJS_BASE not defined. You need to source zjs-env.sh)
 endif
 
 ifeq ($(DEBUGGER), on)
-ifneq ($(BOARD), linux)
-$(error Debugger only runs on linux, set BOARD=linux)
+ifneq (,$(filter $(MAKECMDGOALS), linux arduino_101))
+$(error Debugger only runs on linux and arduino_101)
 endif
+# debugger requires unminimized JS which will require much a larger script size
+SCRIPT_SIZE = 16384
 ifneq ($(SNAPSHOT), on)
 $(warning Debugger on, disabling snapshot)
 SNAPSHOT=off
@@ -120,6 +123,8 @@ else
 SNAPSHOT ?= on
 endif
 
+ZJS_FLAGS += -DMAX_SCRIPT_SIZE=$(SCRIPT_SIZE)
+
 ifeq ($(FUNC_NAME), on)
 ZJS_FLAGS += -DZJS_FIND_FUNC_NAME
 endif
@@ -130,6 +135,11 @@ else
 FORCED := $(FORCE),zjs_common.json
 endif
 
+ifeq ($(DEBUGGER), on)
+# debugger will require networking support
+FORCED := $(FORCED),zjs_debugger.json
+endif
+
 # Settings for ashell builds
 ifneq (,$(filter $(MAKECMDGOALS),ide ashell))
 ASHELL=zjs_ashell_$(ASHELL_TYPE).json
@@ -308,6 +318,7 @@ analyze: $(JS)
 		-DBLE_ADDR=$(BLE_ADDR) \
 		-DBOARD=$(BOARD) \
 		-DCB_STATS=$(CB_STATS) \
+		-DDEBUGGER=$(DEBUGGER) \
 		-DJERRY_BASE=$(JERRY_BASE) \
 		-DJERRY_OUTPUT=$(JERRY_OUTPUT) \
 		-DJERRY_PROFILE=$(OUT)/$(BOARD)/jerry_feature.profile \
@@ -389,10 +400,14 @@ else
 	@echo Creating C string from JS application...
 ifeq ($(BOARD), linux)
 	@./scripts/convert.py $(JS) $(OUT)/include/zjs_script_gen.h
+else
+ifeq ($(DEBUGGER), on)
+	@./scripts/convert.py --full $(OUT)/$(JS_TMP) $(OUT)/include/zjs_script_gen.h
 else
 	@./scripts/convert.py $(OUT)/$(JS_TMP) $(OUT)/include/zjs_script_gen.h
 endif
 endif
+endif
 
 # Run QEMU target
 .PHONY: qemu
@@ -466,6 +481,7 @@ linux: generate
 		-DDEBUGGER=$(DEBUGGER) \
 		-DV=$(V) \
 		-DVARIANT=$(VARIANT) \
+		-DZJS_FLAGS="$(ZJS_FLAGS)" \
 		-H. && \
 	make -C $(OUT)/linux;
 

README.md

@@ -282,12 +282,48 @@ breakpoints such as `b main` and `run` to start debugging as usual with gdb.
 ##### Debugging JavaScript code
 JerryScript has a built-in remote debugger which allows debugging JavaScript
 programs. At the moment only a Websocket-based implementation is provided by
-JerryScript which transmits messages over TCP/IP networks. This implementation
-requires a socket API which currently only work when running on Linux.  The
-socket API is not yet supported with NewLib when building with Zephyr natively.
+JerryScript which transmits messages over TCP/IP networks, but it currently
+only supports ethernet, so you'll need to run it on a board that has ethernet
+support, for example, the FRDM-K64F or Linux.
 
 To enable the remote debugger for a particular JS application:
 ```bash
+make BOARD=frdm_k64f DEBUGGER=on JS=xxx.js
+```
+
+When you flash and run the JS application, it will start in debugging mode,
+running on 192.168.1.101:5001, and you will see the following on serial output:
+
+```bash
+Debugger mode: connect using jerry-client-ws.py
+
+Waiting for client connection
+```
+you might need to add a route on your PC to connect to the network if you
+are connecting the board directly to your PC:
+
+```bash
+ip route add 192.168.1/24 dev eno1
+```
+
+Then you can use the jerryscript command line or html client to connect to the
+debugger to debug your JS application:
+
+python jerryscript/jerry-debugger/jerry-client-ws.py --display 10 192.168.1.1
+
+In the client, type 'help' to get a list of debugger commands, such as
+adding breakpoints, stepping through JS sources, etc.
+
+Alternatively, we've created a client that integrates with Chome DevTools,
+which lets you use the Chrome's built-in debugger to connect and you can
+use it to set breakpoints and step through source from all within the browser.
+Please see installation instructions on how to set it up from
+[here](https://github.com/jerryscript-project/jerryscript-debugger-ts)
+
+##### Debugging JavaScript code on Linux:
+
+To enable the remote debugger on Linux:
+```bash
 make BOARD=linux DEBUGGER=on
 outdir/linux/release/jslinux app.js --debugger
 ```
@@ -296,12 +332,9 @@ It will then be run on debugger mode waiting for client connection, you can then
 in another terminal, you can connect to it by running the python client in
 JerryScript:
 ```bash
-jerry-debugger/jerry-client-ws.py
+python jerryscript/jerry-debugger/jerry-client-ws.py --display 10 localhost
 ```
 
-In the client, type 'help' to get a list of debugger commands, such as
-adding breakpoints, stepping through JS sources, etc.
-
 #### Additional details
 
 See below for a few more tips, such as increasing the space available for your

cmake/jerry.cmake

@@ -4,21 +4,32 @@ include(ExternalProject)
 
 # Additional build flags to work around JerryScript warnings
 set(jerry_cflags " \
- -Wall \
- -Werror \
  -Wno-conversion \
  -Wno-implicit-function-declaration \
  -Wno-old-style-declaration \
- -Wno-undef"
+ -Wno-pedantic \
+ -Wno-shadow \
+ -Wno-sign-compare \
+ -Wno-sign-conversion \
+ -Wno-undef \
+ -Wno-unused-parameter \
+ -Wno-unused-variable"
 )
 
 zephyr_get_include_directories_for_lang_as_string(C includes)
 zephyr_get_system_include_directories_for_lang_as_string(C system_includes)
 zephyr_get_compile_definitions_for_lang_as_string(C definitions)
 zephyr_get_compile_options_for_lang_as_string(C options)
 
+# include the shim layer that ports the network API to build on Zephyr
+if("${DEBUGGER}" STREQUAL "on")
+  set(net_includes
+    "-I${CMAKE_SOURCE_DIR}/src/jerry-port"
+    )
+endif()
+
 set(external_project_cflags
-  "${includes} ${definitions} ${options} ${system_includes}${jerry_cflags}"
+  "${includes} ${definitions} ${options} ${system_includes} ${jerry_cflags} ${net_includes}"
   )
 
 if("${SNAPSHOT}" STREQUAL "on")
@@ -33,10 +44,11 @@ set(CMAKE_ARGS
   -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
   -DCMAKE_C_COMPILER_WORKS=TRUE
   -DCMAKE_SYSTEM_NAME=Zephyr
-  -DENABLE_ALL_IN_ONE=${ALL_IN_ONE}
+  -DENABLE_ALL_IN_ONE=OFF
   -DENABLE_LTO=OFF
   -DEXTERNAL_COMPILE_FLAGS=${external_project_cflags}
   -DFEATURE_ERROR_MESSAGES=ON
+  -DFEATURE_DEBUGGER=${DEBUGGER}
   -DFEATURE_INIT_FINI=ON
   -DFEATURE_PROFILE=${JERRY_PROFILE}
   -DFEATURE_SNAPSHOT_EXEC=OFF

cmake/zjs.cmake

@@ -56,22 +56,35 @@ target_compile_options(app PRIVATE
   -Wno-implicit-function-declaration
   )
 
-target_include_directories(app PRIVATE ./src)
-target_include_directories(app PRIVATE ${ZEPHYR_BASE}/drivers)
-target_include_directories(app PRIVATE ${JERRY_BASE}/jerry-core/include)
-target_include_directories(app PRIVATE ${JERRY_BASE}/jerry-core/jrt)
-target_include_directories(app PRIVATE ${JERRY_BASE}/jerry-ext/include)
-target_include_directories(app PRIVATE ${CMAKE_BINARY_DIR}/../include)
-
-target_sources(app PRIVATE src/main.c)
-target_sources(app PRIVATE src/zjs_callbacks.c)
-target_sources(app PRIVATE src/zjs_common.c)
-target_sources(app PRIVATE src/zjs_error.c)
-target_sources(app PRIVATE src/zjs_modules.c)
-target_sources(app PRIVATE src/zjs_script.c)
-target_sources(app PRIVATE src/zjs_timers.c)
-target_sources(app PRIVATE src/zjs_util.c)
-target_sources(app PRIVATE src/jerry-port/zjs_jerry_port.c)
+set(APP_INCLUDES
+  ./src
+  ${ZEPHYR_BASE}/drivers
+  ${JERRY_BASE}/jerry-core/include
+  ${JERRY_BASE}/jerry-core/jrt
+  ${JERRY_BASE}/jerry-ext/include
+  ${CMAKE_BINARY_DIR}/../include
+  )
+
+set(APP_SRC
+  src/main.c
+  src/zjs_callbacks.c
+  src/zjs_common.c
+  src/zjs_error.c
+  src/zjs_modules.c
+  src/zjs_script.c
+  src/zjs_timers.c
+  src/zjs_util.c
+  src/jerry-port/zjs_jerry_port.c
+  )
+
+if("${DEBUGGER}" STREQUAL "on")
+  add_definitions(-DJERRY_DEBUGGER)
+  add_definitions(-DZJS_DEBUGGER)
+endif()
+
+target_include_directories(app PRIVATE ${APP_INCLUDES})
+
+target_sources(app PRIVATE ${APP_SRC})
 
 target_link_libraries(app jerry-core jerry-ext)
 

cmake/zjs_linux.cmake

@@ -77,12 +77,8 @@ set(APP_COMPILE_OPTIONS
   -std=gnu99
   )
 
-if(CB_STATS)
-  add_definitions(-DCB_STATS=${CB_STATS})
-endif()
-
-if(DEBUGGER)
-  add_definitions(-DZJS_DEBUGGER=${ZJS_DEBUGGER})
+if("${CB_STATS}" STREQUAL "on")
+  add_definitions(-DZJS_PRINT_CALLBACK_STATS)
 endif()
 
 if("${VARIANT}" STREQUAL "debug")
@@ -141,6 +137,17 @@ if(NOT APPLE)
 
   # these flags are needed to get rid of warnings in iotivity-constrained
   list(APPEND APP_COMPILE_OPTIONS -Wno-pointer-sign)
+
+  if("${DEBUGGER}" STREQUAL "on")
+    list(APPEND APP_INCLUDES
+      ${JERRY_BASE}/jerry-core/debugger
+      ${JERRY_BASE}/jerry-core/ecma/base
+      ${JERRY_BASE}/jerry-core/jmem
+      ${JERRY_BASE}/jerry-core/lit
+      )
+    add_definitions(-DJERRY_DEBUGGER)
+    add_definitions(-DZJS_DEBUGGER)
+  endif()
 endif()
 
 # build libjerry as a static library

scripts/convert.py

@@ -20,10 +20,18 @@
 
 def main():
     args = parse_args()
-    minified_result = uglifyjs(args.input)
+    minified_result = None
+    if not args.full:
+        minified_result = uglifyjs(args.input)
+    if minified_result == None:
+        # full JS or couldn't uglify the JS,
+        # return content of the file as is
+        fp = open(str(args.input), "r")
+        content = fp.read()
+        fp.close()
+        minified_result = Uglify(content, False)
     write_minified(args.output, minified_result)
 
-
 def write_minified(output_path, minified_result):
     """Write the minified output, escaping things as necessary
 
@@ -61,6 +69,7 @@ def uglifyjs(input_path):
     :param input_path: A pathlib.Path() object of the input file.
     :returns: An Uglify() object
     """
+
     filename = str(input_path)
     # NOTE(jlvillal): The docs say that '-nc' is the same as '--no-copyright'
     # but in testing it is not.
@@ -73,8 +82,8 @@ def uglifyjs(input_path):
     try:
         result = subprocess.call(cmd_line, stdout=subprocess.DEVNULL)
     except FileNotFoundError:
-        # We don't have uglifyjs, so return the contents of the file
-        return Uglify(input_path.read_text(), False)
+        # We don't have uglifyjs
+        return None
 
     if result == 0:
         # We have newer uglifyjs
@@ -96,6 +105,8 @@ def parse_args():
                      "a C string format."))
     parser.add_argument("input", metavar='INPUT_FILE')
     parser.add_argument("output", metavar='OUTPUT_FILE')
+    parser.add_argument("-f", "--full", help="Skip minimizing JS for debugging",
+                        action="store_true")
     args = parser.parse_args()
     # Make all paths absolute and expand any "~/" usage.
     for arg_name in ('input', 'output'):

scripts/trlite

@@ -332,6 +332,11 @@ if [ "$RUN" == "all" -o "$RUN" == "2" ]; then
     write_modules_test $TMPFILE $MODULES $SENSORS
     try_command "k64f net" make $VERBOSE JS=$TMPFILE ROM=256 BOARD=frdm_k64f
 
+    # debugger test
+    MODULES=(buffer)
+    write_modules_test $TMPFILE $MODULE
+    try_command "k64f debugger" make $VERBOSE JS=$TMPFILE ROM=256 BOARD=frdm_k64f DEBUGGER=on
+
     # OCF test
     echo "var ocf = require('ocf');" > $TMPFILE
     echo "var client = ocf.client;" >> $TMPFILE
@@ -450,6 +455,9 @@ if [ "$RUN" == "all" -o "$RUN" == "3" ]; then
     # linux build tests
     try_command "linux" make $VERBOSE BOARD=linux
 
+    # linux debugger tests
+    try_command "linux debuger" make $VERBOSE BOARD=linux DEBUGGER=on
+
     # linux unit tests
     try_command "unit tests" ./outdir/linux/release/jslinux --unittest
 

src/jerry-port/arpa/inet.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2018, Intel Corporation.
+
+// Zephyr network stack port
+// JerryScript debugger includes <arpa/inet.h> but Zephyr has different headers
+
+#include <sys/fcntl.h>
+#include <net/socket.h>
+
+#define SOL_SOCKET    (1)
+#define SO_REUSEADDR  (201)
+
+#define setsockopt(sd, level, optname, optval, optlen) 0
+
+char addr_str[NET_IPV4_ADDR_LEN];
+
+#define socket(domain, type, protocol) socket(domain, type, IPPROTO_TCP)
+
+inline char *inet_ntoa (struct in_addr addr) {
+    return net_addr_ntop(AF_INET, &addr, addr_str, sizeof(addr_str));
+}