Implement LLVM support for PCRE2

(cherry picked from commit 01420e5)

Author: Pavel Marek

com.oracle.truffle.r.native/fficall/src/truffle_common/pcre2_rffi.c

@@ -46,7 +46,7 @@ typedef void (*match_cb_t)(size_t start_idx, size_t end_idx);
 typedef void (*capture_cb_t)(size_t capture_idx, size_t start_idx, size_t end_idx);
 typedef void (*set_capture_name_cb_t)(const char *name, int index);
 
-pcre2_code *call_pcre2_compile(char *pattern, uint32_t options, int *error_code, int *error_offset);
+pcre2_code *call_pcre2_compile(uint8_t *pattern, size_t pattern_len, uint32_t options, int *error_code, size_t *error_offset);
 uint32_t call_pcre2_capture_count(pcre2_code *re);
 /**
  * Returns the count of all the named captures. A named capture is also a capture, so the number
@@ -77,6 +77,7 @@ int call_pcre2_match(
     capture_cb_t capture_cb,
     pcre2_code *re,
     uint8_t *subject,
+    size_t subject_len,
     uint32_t options,
     int stop_after_first_match
 );
@@ -90,13 +91,10 @@ static void report_captures(capture_cb_t capture_cb, uint32_t capture_count, con
 static size_t advance_offset(size_t offset, int utf8, const uint8_t *subject, size_t subject_len);
 
 
-// TODO: error_offset should be `size_t`.
-pcre2_code *call_pcre2_compile(char *pattern_str, uint32_t options, int *error_code, int *error_offset)
+pcre2_code *call_pcre2_compile(uint8_t *pattern, size_t pattern_len, uint32_t options, int *error_code, size_t *error_offset)
 {
-    uint8_t *pattern = (uint8_t *) pattern_str;
-    size_t pattern_len = strlen(pattern);
 #ifdef FASTR_PCRE2_DEBUG
-    printf("call_pcre2_compile: pattern_str='%s', pattern_len=%u, pattern=[", pattern, pattern_len);
+    printf("call_pcre2_compile: pattern_str='%s', pattern_len=%lu, pattern=[", pattern, pattern_len);
     for (int i = 0; i < pattern_len; i++) {
         printf("%u, ", pattern[i]);
     }
@@ -147,7 +145,7 @@ int call_pcre2_get_capture_names(void (*set_capture_name_cb)(const char *name, i
         // ovector begins with match, capture groups are after that.
         int capture_idx = ovector_idx - 1;
         uint8_t *name = tabptr + 2;
-        set_capture_name_cb((const char *)name, capture_idx);
+        set_capture_name_cb((const char *)ensure_string(name), capture_idx);
         tabptr += name_entry_size;
     }
     return names_count;
@@ -158,11 +156,11 @@ int call_pcre2_match(
     capture_cb_t capture_cb,
     pcre2_code *re,
     uint8_t *subject,
+    size_t subject_len,
     uint32_t first_match_options,
     int stop_after_first_match
 )
 {
-    size_t subject_len = strlen((char *) subject);
     pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
     uint32_t capture_count = call_pcre2_capture_count(re);
 
@@ -178,6 +176,7 @@ int call_pcre2_match(
     // rc corresponds to the count of captured groups plus one, or error code if rc is negative.
     int rc = pcre2_match(re, subject, subject_len, 0, first_match_options, match_data, NULL);
     if (rc == PCRE2_ERROR_NOMATCH) {
+        pcre2_match_data_free(match_data);
         return 0;
     } else if (rc < 0) {
         pcre2_match_data_free(match_data);

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ffi/NativeFunction.java

@@ -47,10 +47,10 @@ public enum NativeFunction {
     umask("(sint32): sint32", "call_base_"),
     cpolyroot("([double], [double], sint32, [double], [double]): sint32", "call_base_", baseLibrary(), true),
     // PCRE2 (in pcre2_rffi.c)
-    compile("(string, uint32, [sint32], [sint32]): pointer", "call_pcre2_"),
-    match("((uint32, uint32): void, (uint32, uint32, uint32): void, pointer, [uint8], uint32, sint32): sint32", "call_pcre2_"),
+    compile("([uint8], uint32, uint32, [sint32], [uint32]): pointer", "call_pcre2_"),
+    match("((uint32, uint32): void, (uint32, uint32, uint32): void, pointer, [uint8], uint32, uint32, sint32): sint32", "call_pcre2_"),
     capture_count("(pointer): uint32", "call_pcre2_"),
-    names_count("(point): uint32", "call_pcre2_"),
+    names_count("(pointer): uint32", "call_pcre2_"),
     get_capture_names("((string, sint32): void, pointer): sint32", "call_pcre2_"),
     match_count("(pointer, string, sint32, sint32, uint32): sint32", "call_pcre2_"),
     pattern_free("(pointer): void", "call_pcre2_"),

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ffi/PCRE2RFFI.java

@@ -420,7 +420,9 @@ public CompileResult execute(String pattern, int options) {
             int[] errorOffSet = new int[]{-1};
             // We want to enable UTF-based matching by default.
             options |= Option.UTF.value;
-            Object pcreCode = call(NativeFunction.compile, pattern, options, errorCode, errorOffSet);
+            byte[] patternBytes = pattern.getBytes(StandardCharsets.UTF_8);
+            NativeCharArray patternCharArray = new NativeCharArray(patternBytes);
+            Object pcreCode = call(NativeFunction.compile, patternCharArray, patternBytes.length, options, errorCode, errorOffSet);
             String errorMessage = null;
             if (interop.isNull(pcreCode)) {
                 assert errorOffSet[0] >= 0;
@@ -478,6 +480,8 @@ public String[] execute(Object pcrePattern, int captureCount) {
     }
 
     public static final class MatchNode extends NativeCallNode {
+        @Child private GetErrorStringNode getErrorStringNode = RFFIFactory.getPCRE2RFFI().createGetErrorStringNode();
+
         public MatchNode(DownCallNodeFactory downCallNodeFactory) {
             super(downCallNodeFactory.createDownCallNode());
         }
@@ -499,16 +503,20 @@ public MatchData execute(Object pcreCompiledPattern, String subject, int options
             MatchCallback matchCallback = new MatchCallback(matchData);
             CaptureCallback captureCallback = new CaptureCallback(matchData);
             byte[] subjectBytes = subject.getBytes(StandardCharsets.UTF_8);
-            NativeCharArray nativeCharArray = new NativeCharArray(subjectBytes);
+            NativeCharArray subjectCharArray = new NativeCharArray(subjectBytes);
             Object matchCount = call(NativeFunction.match, matchCallback, captureCallback,
-                            pcreCompiledPattern, nativeCharArray, options, stopAfterFirstMatch ? 1 : 0);
+                            pcreCompiledPattern, subjectCharArray, subjectBytes.length, options, stopAfterFirstMatch ? 1 : 0);
             assert InteropLibrary.getUncached().isNumber(matchCount);
             int matchCountInt;
             try {
                 matchCountInt = InteropLibrary.getUncached().asInt(matchCount);
             } catch (UnsupportedMessageException e) {
                 throw RInternalError.shouldNotReachHere(e);
             }
+            if (matchCountInt < 0) {
+                String errMessage = getErrorStringNode.execute(matchCountInt);
+                throw RInternalError.shouldNotReachHere("PCRE2Rffi$MatchNode: match failed with " + errMessage);
+            }
             assert matchCountInt == matchData.getMatchCount();
             matchData = convertIndexes(matchData, subject, subjectBytes, captureCount);
             matchData.padCapturesWithEmptyMatches();

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ffi/interop/NativeCharArray.java

@@ -33,6 +33,15 @@
 /**
  * A {@link TruffleObject} that represents an array of {@code unsigned char} values, that is
  * {@code NULL} terminated in the C domain.
+ *
+ * Note that {@link #getArrayLength()} returns effective length, which means that the length
+ * also includes the terminating null.
+ *
+ * Beware of using {@code strlen} on instances of this
+ * class, as it will return different results on LLVM and on NFI (on LLVM, the return value
+ * will include the terminating null). If you plan to use an instance of this class as string
+ * in native code, pass along the length of the string to the native, do not compute it in
+ * the native code via {@code strlen}.
  */
 @ExportLibrary(InteropLibrary.class)
 public final class NativeCharArray extends NativeUInt8Array {

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ffi/interop/NativeUInt8Array.java

@@ -29,7 +29,7 @@
 
 /**
  * Parent class of {@link NativeRawArray} and {@link NativeCharArray}, that holds the common logic
- * for a C type {@code uint8*}, that may or may not be {@code NULL} terminated (in the C domain).
+ * for a C type {@code uint8_t*}, that may or may not be {@code NULL} terminated (in the C domain).
  *
  * The null termination is faked for Java arrays. If this object escapes to native code and we
  * allocate native memory for it, then the native memory will be null terminated (and one byte