hm-pt-core 1.0.1 → 1.0.3

package/README.md

@@ -19,7 +19,7 @@ npm install hm-pt-core
 
 | hm-pt-core | hiperf_txt_parser | hmtrace-parser |
 |------------|-------------------|----------------|
-| 1.0.x      | 2.0.x             | 0.8.x          |
+| 1.0.x（当前 **1.0.3**） | **2.1.x**             | **0.8.x**          |
 
 ## 开发
 

package/dist/index.d.ts

@@ -9,5 +9,5 @@ export type { Endian, BuildTraceParserRegistryOptions } from "./trace/parse.js";
 export { TraceFieldDecodeError } from "./trace/parse.js";
 export type { PrintfSpec } from "./trace/printf.js";
 export { parseTraceFormat, parseCommonFieldsFromRaw, parseAllFieldsFromRaw, rawHexLinesToBuffer, bufferToRawHexLines, buildTraceParserRegistry, } from "./trace/parse.js";
-export { formatPrintfValue, tokenizePrintfFormat } from "./trace/printf.js";
+export { formatPrintfValue, tokenizePrintfFormat, renderPrintFmt, renderPrintFmtAsFieldDict } from "./trace/printf.js";
 export { decodeRawByRegistry } from "./trace/decode_raw.js";

package/dist/index.js

@@ -4,5 +4,5 @@
 export { isPerfDataLike } from "./perf/is_perf_data_like.js";
 export { TraceFieldDecodeError } from "./trace/parse.js";
 export { parseTraceFormat, parseCommonFieldsFromRaw, parseAllFieldsFromRaw, rawHexLinesToBuffer, bufferToRawHexLines, buildTraceParserRegistry, } from "./trace/parse.js";
-export { formatPrintfValue, tokenizePrintfFormat } from "./trace/printf.js";
+export { formatPrintfValue, tokenizePrintfFormat, renderPrintFmt, renderPrintFmtAsFieldDict } from "./trace/printf.js";
 export { decodeRawByRegistry } from "./trace/decode_raw.js";

package/dist/trace/decode_raw.js

@@ -21,9 +21,10 @@ export function decodeRawByRegistry(raw, registry, options = {}) {
         };
     }
     const allFields = parseAllFieldsFromRaw(raw, fmt);
+    const renderContext = { eventName: fmt.eventName, eventId };
     const mode = options.tracePrintMode ?? "printf";
     if (fmt.printFmt && mode === "fieldDict") {
-        let renderedFieldDict = renderPrintFmtAsFieldDict(fmt.printFmt, fmt.printArgs, allFields);
+        let renderedFieldDict = renderPrintFmtAsFieldDict(fmt.printFmt, fmt.printArgs, allFields, renderContext);
         const transform = registry.transformFieldDictByEventId?.get(eventId);
         if (transform) {
             renderedFieldDict = transform({
@@ -42,7 +43,9 @@ export function decodeRawByRegistry(raw, registry, options = {}) {
             skipped: false,
         };
     }
-    const renderedText = fmt.printFmt ? renderPrintFmt(fmt.printFmt, fmt.printArgs, allFields) : undefined;
+    const renderedText = fmt.printFmt
+        ? renderPrintFmt(fmt.printFmt, fmt.printArgs, allFields, renderContext)
+        : undefined;
     return {
         commonType: eventId,
         commonFields,

package/dist/trace/parse.js

@@ -138,6 +138,24 @@ function scanBalancedPrintArgs(argsPart) {
     }
     return args;
 }
+/**
+ * 从 print fmt 逗号后参数段提取表达式。
+ * 内核 trace 常在首个 __data_loc 参数外套 ((char*)((void *)...))，括号平衡切分只得 1 段；
+ * 此时回退为按 `REC->` 切分（与 hiperf 1.x 行为一致）。
+ */
+function parsePrintArgExpressions(argsPart) {
+    const balanced = scanBalancedPrintArgs(argsPart);
+    const recExprs = argsPart.match(/REC->[^,]+/g)?.map((s) => s.trim().replace(/\)+$/, "")) ?? [];
+    if (recExprs.length > balanced.length) {
+        return recExprs;
+    }
+    if (recExprs.length === 1 &&
+        balanced.length === 1 &&
+        balanced[0] !== recExprs[0]) {
+        return recExprs;
+    }
+    return balanced;
+}
 function parsePrintFmtLine(line) {
     const prefix = line.match(/^print\s+fmt\s*:\s*/i);
     if (!prefix)
@@ -151,7 +169,7 @@ function parsePrintFmtLine(line) {
     const argsMatch = rest.match(/^,\s*(.*)$/);
     if (!argsMatch)
         return undefined;
-    return { printFmt: lit.value, printArgs: scanBalancedPrintArgs(argsMatch[1]) };
+    return { printFmt: lit.value, printArgs: parsePrintArgExpressions(argsMatch[1]) };
 }
 function splitTypeAndName(rest) {
     const trimmed = rest.trim();
@@ -222,13 +240,89 @@ function isCharType(typeName) {
     const t = normalizeType(typeName);
     return t === "char" || t === "signed char" || t === "unsigned char";
 }
+function isDataLocType(typeName) {
+    return normalizeType(typeName).includes("__data_loc");
+}
+function parseDataLocElementType(typeName, signed) {
+    const t = normalizeType(typeName);
+    const m = t.match(/^__data_loc\s+(.+)\[\]$/);
+    if (!m)
+        return undefined;
+    const elemTypeName = m[1].trim();
+    const elemSize = inferScalarSize(elemTypeName, signed);
+    if (elemSize === undefined)
+        return undefined;
+    return { elemTypeName, elemSize, signed: isSignedElementType(elemTypeName, signed) };
+}
+function isSignedElementType(elemTypeName, fieldSigned) {
+    const t = normalizeType(elemTypeName);
+    if (t.includes("unsigned"))
+        return false;
+    if (t === "char" && !fieldSigned)
+        return false;
+    return fieldSigned || t === "signed char" || t === "short" || t === "int" || t === "long" || t === "long long" || t === "__s64";
+}
+function inferScalarSize(typeName, signed) {
+    const t = normalizeType(typeName);
+    if (t.includes("double"))
+        return 8;
+    if (t.includes("long long") || t === "__s64")
+        return 8;
+    if (t.includes("long"))
+        return 8;
+    if (t.includes("short"))
+        return 2;
+    if (t.includes("char") || t.includes("int") || t.includes("float"))
+        return 4;
+    if (t.includes("unsigned") || signed)
+        return 4;
+    return undefined;
+}
+function assertFieldInBounds(fieldName, offset, size, rawLength) {
+    if (offset < 0 || offset + size > rawLength) {
+        throw new TraceFieldDecodeError(`Field "${fieldName}" out of bounds: offset=${offset}, size=${size}, raw.length=${rawLength}`, fieldName, offset, size, rawLength);
+    }
+}
+function readLocatorField(view, field) {
+    assertFieldInBounds(field.name, field.offset, field.size, view.byteLength);
+    const locField = {
+        ...field,
+        typeName: "unsigned int",
+        signed: false,
+        size: 4,
+    };
+    const loc = readFieldScalarUnchecked(view, locField);
+    if (typeof loc !== "number") {
+        throw new TraceFieldDecodeError(`Field "${field.name}" __data_loc locator is invalid`, field.name, field.offset, field.size, view.byteLength);
+    }
+    return loc;
+}
+function readDynamicRegionAsArray(raw, view, field, dataOffset, byteLen, elemTypeName, elemSize, elemSigned) {
+    if (byteLen === 0)
+        return [];
+    if (byteLen % elemSize !== 0) {
+        throw new TraceFieldDecodeError(`Field "${field.name}" __data_loc length ${byteLen} is not divisible by element size ${elemSize}`, field.name, dataOffset, byteLen, raw.length);
+    }
+    assertFieldInBounds(field.name, dataOffset, byteLen, raw.length);
+    const count = byteLen / elemSize;
+    const values = [];
+    for (let i = 0; i < count; i++) {
+        const elemField = {
+            typeName: elemTypeName,
+            name: field.name,
+            offset: dataOffset + i * elemSize,
+            size: elemSize,
+            signed: elemSigned,
+        };
+        values.push(readFieldScalarUnchecked(view, elemField));
+    }
+    return values;
+}
 /**
  * 从 little-endian 原始缓冲区按字段描述读一个标量
  */
-function readFieldScalar(view, field) {
+function readFieldScalarUnchecked(view, field) {
     const { offset, size, signed, typeName } = field;
-    if (offset + size > view.byteLength)
-        return undefined;
     const t = normalizeType(typeName);
     if (size === 1) {
         if (signed || t === "signed char") {
@@ -260,7 +354,14 @@ function readFieldScalar(view, field) {
         }
         return view.getBigUint64(offset, true);
     }
-    return undefined;
+    throw new TraceFieldDecodeError(`Field "${field.name}" has unsupported scalar size ${size}`, field.name, offset, size, view.byteLength);
+}
+/**
+ * 从 little-endian 原始缓冲区按字段描述读一个标量；越界时抛出 TraceFieldDecodeError。
+ */
+function readFieldScalar(view, field) {
+    assertFieldInBounds(field.name, field.offset, field.size, view.byteLength);
+    return readFieldScalarUnchecked(view, field);
 }
 function parseArrayName(name) {
     const m = name.match(/^(\w+)\[(\d+)\]$/);
@@ -274,9 +375,10 @@ function readFieldValue(view, field) {
         return readFieldScalar(view, field);
     if (arr.len <= 0)
         return [];
-    const elemSize = Math.floor(field.size / arr.len);
-    if (elemSize <= 0)
-        return undefined;
+    if (field.size % arr.len !== 0) {
+        throw new TraceFieldDecodeError(`Field "${field.name}" size ${field.size} is not divisible by array length ${arr.len}`, field.name, field.offset, field.size, view.byteLength);
+    }
+    const elemSize = field.size / arr.len;
     const values = [];
     for (let i = 0; i < arr.len; i++) {
         const elemField = {
@@ -285,10 +387,7 @@ function readFieldValue(view, field) {
             offset: field.offset + i * elemSize,
             size: elemSize,
         };
-        const v = readFieldScalar(view, elemField);
-        if (v === undefined)
-            return undefined;
-        values.push(v);
+        values.push(readFieldScalar(view, elemField));
     }
     return values;
 }
@@ -301,10 +400,9 @@ export function parseCommonFieldsFromRaw(raw, format) {
     for (const field of format.fields) {
         if (!field.name.startsWith("common_"))
             continue;
-        const v = readFieldScalar(view, field);
-        if (v !== undefined) {
-            out[field.name] = v;
-        }
+        if (field.offset + field.size > view.byteLength)
+            continue;
+        out[field.name] = readFieldScalar(view, field);
     }
     return out;
 }
@@ -318,26 +416,18 @@ export function parseAllFieldsFromRaw(raw, format) {
         const arr = parseArrayName(field.name);
         const key = arr ? arr.baseName : field.name;
         const t = normalizeType(field.typeName);
-        // __data_loc char[] reason: 实际存一个 u32，低 16 位为 offset，高 16 位为 length
-        if (t.includes("__data_loc") && t.includes("char")) {
-            const locField = {
-                ...field,
-                typeName: "unsigned int",
-                signed: false,
-                size: 4,
-            };
-            const loc = readFieldScalar(view, locField);
-            if (typeof loc === "number") {
-                const locKey = `__data_loc_${field.name}`;
-                out[locKey] = loc;
-                const offset = loc & 0xffff;
-                const len = (loc >>> 16) & 0xffff;
-                if (len > 0 && (offset < 0 || offset + len > raw.length)) {
-                    throw new TraceFieldDecodeError(`Field "${field.name}" __data_loc out of bounds: offset=${offset}, len=${len}, raw.length=${raw.length}`, field.name, offset, len, raw.length);
-                }
-                if (offset >= 0 && len > 0 && offset + len <= raw.length) {
-                    const bytes = raw.subarray(offset, offset + len);
-                    // 去掉末尾 \0
+        if (isDataLocType(field.typeName)) {
+            const loc = readLocatorField(view, field);
+            const locKey = `__data_loc_${field.name}`;
+            out[locKey] = loc;
+            const dataOffset = loc & 0xffff;
+            const byteLen = (loc >>> 16) & 0xffff;
+            if (byteLen > 0 && (dataOffset < 0 || dataOffset + byteLen > raw.length)) {
+                throw new TraceFieldDecodeError(`Field "${field.name}" __data_loc out of bounds: offset=${dataOffset}, len=${byteLen}, raw.length=${raw.length}`, field.name, dataOffset, byteLen, raw.length);
+            }
+            if (t.includes("char")) {
+                if (byteLen > 0) {
+                    const bytes = raw.subarray(dataOffset, dataOffset + byteLen);
                     const nul = bytes.indexOf(0);
                     const slice = nul >= 0 ? bytes.subarray(0, nul) : bytes;
                     out[field.name] = UTF8_DECODER.decode(slice);
@@ -345,17 +435,20 @@ export function parseAllFieldsFromRaw(raw, format) {
                 else {
                     out[field.name] = "";
                 }
+                continue;
+            }
+            const elemInfo = parseDataLocElementType(field.typeName, field.signed);
+            if (!elemInfo) {
+                throw new TraceFieldDecodeError(`Field "${field.name}" uses unsupported __data_loc element type "${field.typeName}"`, field.name, field.offset, field.size, raw.length);
             }
+            out[key] = readDynamicRegionAsArray(raw, view, field, dataOffset, byteLen, elemInfo.elemTypeName, elemInfo.elemSize, elemInfo.signed);
             continue;
         }
         if (arr && isCharType(field.typeName)) {
             out[key] = readCharArrayAsString(raw, field.offset, field.size, field.name);
             continue;
         }
-        const v = readFieldValue(view, field);
-        if (v !== undefined) {
-            out[key] = v;
-        }
+        out[key] = readFieldValue(view, field);
     }
     return out;
 }
@@ -450,6 +543,9 @@ export function buildTraceParserRegistry(formatTexts, options = {}) {
             if (typeof src !== "string" && src.transformFieldDict) {
                 transformFieldDictByEventId.set(fmt.eventId, src.transformFieldDict);
             }
+            else {
+                transformFieldDictByEventId.delete(fmt.eventId);
+            }
         }
     });
     return {

package/dist/trace/printf.d.ts

@@ -29,6 +29,10 @@ export declare function tokenizePrintfFormat(printFmt: string): Array<{
     kind: "spec";
     spec: PrintfSpec;
 }>;
+export interface PrintFmtRenderContext {
+    eventName?: string;
+    eventId?: number;
+}
 /** 测试专用：重置 printf 解析缓存 */
 export declare function resetPrintfCachesForTest(): void;
 /** 测试专用：读取 printf 解析缓存条目数 */
@@ -36,6 +40,6 @@ export declare function getPrintfCacheSizesForTest(): {
     tokens: number;
     specs: number;
 };
-export declare function renderPrintFmtAsFieldDict(printFmt: string, printArgs: string[] | undefined, fieldMap: PrintFieldMap): Record<string, string>;
-export declare function renderPrintFmt(printFmt: string, printArgs: string[] | undefined, fieldMap: PrintFieldMap): string;
+export declare function renderPrintFmtAsFieldDict(printFmt: string, printArgs: string[] | undefined, fieldMap: PrintFieldMap, context?: PrintFmtRenderContext): Record<string, string>;
+export declare function renderPrintFmt(printFmt: string, printArgs: string[] | undefined, fieldMap: PrintFieldMap, context?: PrintFmtRenderContext): string;
 export {};

package/dist/trace/printf.js

@@ -158,11 +158,21 @@ function formatPrintfUnsignedRadix(unsigned, spec, radix, upper) {
                 : unsigned.toString(radix);
         body = body.padStart(Math.max(prec, body.length), "0");
     }
-    if (hasPrintfFlag(spec.flags, "#") && unsigned !== 0n) {
-        if (radix === 16)
+    if (hasPrintfFlag(spec.flags, "#")) {
+        if (radix === 16 && unsigned !== 0n) {
             prefix = upper ? "0X" : "0x";
-        else if (radix === 8 && body !== "0" && !body.startsWith("0"))
-            prefix = "0";
+        }
+        else if (radix === 8) {
+            if (unsigned === 0n && (prec === 0 || body === "")) {
+                body = "0";
+            }
+            else if (body === "") {
+                body = "0";
+            }
+            else if (!body.startsWith("0")) {
+                body = "0" + body;
+            }
+        }
     }
     const zeroPad = hasPrintfFlag(spec.flags, "0") &&
         !hasPrintfFlag(spec.flags, "-") &&
@@ -333,6 +343,16 @@ export function tokenizePrintfFormat(printFmt) {
     flushText();
     return out;
 }
+function assertPrintArgCount(printFmt, printArgs, context) {
+    const specCount = extractPrintfSpecs(printFmt).length;
+    const argCount = printArgs?.length ?? 0;
+    if (argCount < specCount) {
+        const eventLabel = context?.eventName !== undefined
+            ? `"${context.eventName}"${context.eventId !== undefined ? ` (ID ${context.eventId})` : ""}`
+            : "unknown event";
+        throw new Error(`Print fmt for event ${eventLabel} requires ${specCount} args but got ${argCount} at spec index ${argCount}: "${printFmt}"`);
+    }
+}
 function extractPrintfSpecs(printFmt) {
     const cached = PRINT_FMT_SPEC_CACHE.get(printFmt);
     if (cached)
@@ -401,12 +421,20 @@ function evalPrintArgExpr(exprRaw, fieldMap) {
             return v;
         throw new Error(`__get_str(${m[1]}) requires a string field, got ${typeof v}`);
     }
-    m = expr.match(/^__get_dynamic_array\((\w+)\)$/);
+    m = expr.match(/^__get_dynamic_array\((\w+)\)(?:\[(\d+)])?$/);
     if (m) {
         const v = fieldMap[m[1]];
-        if (Array.isArray(v))
-            return v;
-        throw new Error(`__get_dynamic_array(${m[1]}) requires an array field, got ${typeof v}`);
+        if (!Array.isArray(v)) {
+            throw new Error(`__get_dynamic_array(${m[1]}) requires an array field, got ${typeof v}`);
+        }
+        if (m[2] !== undefined) {
+            const idx = parseInt(m[2], 10);
+            if (idx < 0 || idx >= v.length) {
+                throw new Error(`Invalid print arg index for __get_dynamic_array(${m[1]})[${m[2]}]`);
+            }
+            return v[idx];
+        }
+        return v;
     }
     m = expr.match(/^REC->(\w+)&0xffff$/);
     if (m) {
@@ -481,9 +509,9 @@ function fieldKeyFromNormalizedArg(normalizedArg, index) {
     if (mGetStr) {
         return mGetStr[1];
     }
-    const mGetArr = k.match(/^__get_dynamic_array\((\w+)\)$/);
+    const mGetArr = k.match(/^__get_dynamic_array\((\w+)\)(?:\[(\d+)])?$/);
     if (mGetArr) {
-        return mGetArr[1];
+        return mGetArr[2] !== undefined ? `${mGetArr[1]}__${mGetArr[2]}` : mGetArr[1];
     }
     // REC->__data_loc_path&0xffff 在 fieldDict 中收敛为 path 作为键名
     const mDataLocOff = k.match(/^__data_loc_(\w+)&0xffff$/);
@@ -492,7 +520,8 @@ function fieldKeyFromNormalizedArg(normalizedArg, index) {
     }
     return k.length > 0 ? k : `arg${index}`;
 }
-export function renderPrintFmtAsFieldDict(printFmt, printArgs, fieldMap) {
+export function renderPrintFmtAsFieldDict(printFmt, printArgs, fieldMap, context) {
+    assertPrintArgCount(printFmt, printArgs, context);
     const { normalizedArgs, values } = buildPrintArgValues(printArgs, fieldMap);
     const specs = extractPrintfSpecs(printFmt);
     const out = {};
@@ -506,7 +535,8 @@ export function renderPrintFmtAsFieldDict(printFmt, printArgs, fieldMap) {
     }
     return out;
 }
-export function renderPrintFmt(printFmt, printArgs, fieldMap) {
+export function renderPrintFmt(printFmt, printArgs, fieldMap, context) {
+    assertPrintArgCount(printFmt, printArgs, context);
     const { normalizedArgs, values } = buildPrintArgValues(printArgs, fieldMap);
     const tokens = getCachedPrintfTokens(printFmt);
     let argIdx = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hm-pt-core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "DFX perf trace shared types and trace format decode primitives",
   "type": "module",
   "main": "dist/index.js",