| /* --COPYRIGHT--,ESD |
| * Copyright (c) 2008-2019 Texas Instruments Incorporated |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v1.0 and Eclipse Distribution License |
| * v. 1.0 which accompanies this distribution. The Eclipse Public License is |
| * available at http://www.eclipse.org/legal/epl-v10.html and the Eclipse |
| * Distribution License is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * Contributors: |
| * Texas Instruments - initial implementation |
| * --/COPYRIGHT--*/ |
| /* |
| * ======== Log.xs ======== |
| */ |
| |
| var Defaults = xdc.module('xdc.runtime.Defaults'); |
| var Diags = xdc.module('xdc.runtime.Diags'); |
| |
| /* |
| * ======== lookupEventMessage ======== |
| * Returns the format string for the event with the given id. |
| */ |
| function lookupEventMessage(eventId) |
| { |
| var Program = xdc.useModule('xdc.rov.Program'); |
| |
| /* Get the Log module's configuration object. */ |
| var cfg = Program.getModuleConfig('xdc.runtime.Log'); |
| |
| if (cfg.idToInfo["#" + eventId] == undefined) { |
| return ("<ERROR: No message found for eventId #" + eventId + ">"); |
| } |
| else { |
| return (cfg.idToInfo["#" + eventId].split('::')[1]); |
| } |
| } |
| |
| /* |
| * ======== getTargetArgSize ======== |
| * Returns the target size of a record argument in bytes (not MAUs). |
| */ |
| function getTargetArgSize() |
| { |
| /* Guaranteed to be 4 bytes on all targets. */ |
| return (4); |
| } |
| |
| /* |
| * ======== lookupEventName ======== |
| */ |
| function lookupEventName(eventId) |
| { |
| var Program = xdc.useModule('xdc.rov.Program'); |
| |
| /* Get the Log module's configuration object. */ |
| var cfg = Program.getModuleConfig('xdc.runtime.Log'); |
| |
| if (cfg.idToInfo["#" + eventId] != undefined) { |
| return (cfg.idToInfo["#" + eventId].split('::')[0]); |
| } |
| else if (info.eventId == 0) { |
| return ("Log_print"); |
| } |
| else { |
| return ("Unrecognized event id: " + eventId); |
| } |
| } |
| |
| /* |
| * ======== lookupModuleName ======== |
| */ |
| function lookupModuleName(modId) |
| { |
| var Program = xdc.useModule('xdc.rov.Program'); |
| return (Program.moduleIdToName(modId)); |
| } |
| |
| /* |
| * ======== getTargetEventRecSize ======== |
| * Returns the record size in bytes (not MAUs). |
| */ |
| function getTargetEventRecSize() |
| { |
| var bytesPerMau = Program.build.target.bitsPerChar / 8; |
| return (this.EventRec.$sizeof() * bytesPerMau); |
| } |
| |
| /* |
| * ======== Event$alignof ======== |
| * Return alignment required for an encoded value of an EventDesc |
| */ |
| function Event$alignof() |
| { |
| return (Program.build.target.stdTypes.t_Int32.align); |
| } |
| |
| /* |
| * ======== Event$encode ======== |
| * Return a C expression that evaluates to the encoded value of an EventDesc |
| */ |
| function Event$encode(desc) |
| { |
| var encodedDesc = "0"; |
| |
| if (desc) { |
| /* If Log calls are eliminated from the source code in case of custom |
| * builds, we don't need Log events. |
| */ |
| if (desc.$private.id == $$NOGEN) { |
| return($$NOGEN); |
| } |
| |
| /* |
| * Determine the event's priority. If none is specified, give it the |
| * max priority so that it isn't inadvertently filtered out. |
| */ |
| var priMask; |
| if (desc.level != undefined) { |
| priMask = desc.level; |
| } |
| else { |
| priMask = Diags.LEVEL1; |
| } |
| |
| /* Determine the mask value by combining the event mask and priority */ |
| var maskVal = (desc.mask | priMask) & 0xFFFF; |
| |
| /* If no IDs were assigned, Log is not used, but we still need to |
| * generate events for modules that define Log_Events. |
| */ |
| var id = desc.$private.id == undefined ? 0 : desc.$private.id; |
| |
| encodedDesc = "(((xdc_runtime_Log_Event)" + id + ") << 16 | " |
| + maskVal + ")"; |
| } |
| |
| return (encodedDesc); |
| } |
| |
| /* |
| * ======== Event$sizeof ======== |
| * Return sizeof the encoded value of an EventDesc |
| */ |
| function Event$sizeof() |
| { |
| return (Program.build.target.stdTypes.t_Int32.size); |
| } |
| |
| /* |
| * ======== module$use ======== |
| */ |
| function module$use() |
| { |
| xdc.useModule('xdc.runtime.Diags'); |
| } |
| |
| /* |
| * ======== module$static$init ======== |
| */ |
| function module$static$init(obj, params) |
| { |
| var Text = xdc.module('xdc.runtime.Text'); |
| var Diags = xdc.module('xdc.runtime.Diags'); |
| var internalCounter = 1; |
| |
| var pkgVers = {}; |
| for each (var mod in Program.targetModules()) { |
| |
| if (mod.PROXY$) { |
| continue; |
| } |
| |
| /* create an Id for all Log_Event's declared in the module */ |
| if ('$$logEvtCfgs' in mod && mod.$$logEvtCfgs.length > 0) { |
| for each (var cn in mod.$$logEvtCfgs) { |
| var desc = mod[cn]; |
| /* If Text is disabled, there are no strings in Text to manage |
| * and we don't want anything in 'idToInfo' and no warning about |
| * the same ids. |
| */ |
| if (Text.isLoaded) { |
| desc.$private.id = Text.defineRopeCord(desc.msg); |
| } |
| else { |
| /* We still need to supply an ID because the API promises |
| * that all Log Events from a module are within a range and |
| * no other modules get an ID from that range. |
| */ |
| desc.$private.id = internalCounter++; |
| } |
| |
| var key = "#" + desc.$private.id; |
| if (this.idToInfo[key] != null) { |
| var Warnings = xdc.module('xdc.Warnings'); |
| var oldEvent = this.idToInfo[key].split('::'); |
| this.$logWarning({warning: Warnings.LOGID, args: |
| [mod.$name + '.' + cn, oldEvent[0], oldEvent[1]]}, |
| this, "idToInfo"); |
| } |
| this.idToInfo[key] = mod.$name + '.' + cn + '::' + desc.msg; |
| } |
| } |
| |
| /* "inherit" the default logger */ |
| mod.Module__loggerObj = mod.common$.logger; |
| |
| if (mod.common$.logger) { |
| var cn = mod.common$.logger.$orig.$module.$name; |
| |
| mod.Module__loggerFxn0 = $externModFxn(cn + '.write0'); |
| mod.Module__loggerFxn1 = $externModFxn(cn + '.write1'); |
| mod.Module__loggerFxn2 = $externModFxn(cn + '.write2'); |
| mod.Module__loggerFxn4 = $externModFxn(cn + '.write4'); |
| mod.Module__loggerFxn8 = $externModFxn(cn + '.write8'); |
| mod.Module__loggerDefined = true; |
| } |
| |
| /* generate log event ids for loggable fxns in the module */ |
| var res = null; |
| if ('$$loggables' in mod && mod.$$loggables.length > 0) { |
| res = ""; |
| var sep = ""; |
| var id; |
| var msg; |
| var desc; |
| for each (var fxn in mod.$$loggables) { |
| res += sep; |
| sep = ","; |
| res += fxn.name; |
| |
| if (query(mod, 'ENTRY')) { |
| msg = "--> " + fxn.name + ": (" + fxn.entry + ")"; |
| desc = new this.EventDesc({msg: msg}); |
| if (Text.isLoaded) { |
| id = Text.defineRopeCord(msg); |
| } |
| else { |
| id = internalCounter++; |
| } |
| this.idToInfo['#' + id] = mod.$name + '.' + fxn.name + |
| '$ENTRY' + '::' + desc.msg; |
| desc.$private.id = id; |
| id = (id << 16) | Diags.ENTRY; |
| } |
| else { |
| id = 0; |
| } |
| res += ":" + id; |
| |
| if (query(mod, 'EXIT')) { |
| msg = "<-- " + fxn.name + ": " + |
| (fxn.exit ? fxn.exit : "void"); |
| desc = new this.EventDesc({msg: msg}); |
| if (Text.isLoaded) { |
| id = Text.defineRopeCord(msg); |
| } |
| else { |
| id = internalCounter++; |
| } |
| this.idToInfo['#' + id] = mod.$name + '.' + fxn.name + |
| '$EXIT' + '::' + desc.msg; |
| desc.$private.id = id; |
| id = (id << 16) | Diags.EXIT; |
| } |
| else { |
| id = 0; |
| } |
| res += ":" + id; |
| } |
| } |
| |
| /* record any generated event id's in module |
| * $$fxnEvtIds = "fxn_name:enter_id:exit_id,..." |
| */ |
| mod.$$bind('$$fxnEvtIds', res); |
| } |
| } |
| |
| /* |
| * ======== query ======== |
| */ |
| function query(mod, dl) |
| { |
| var sel = 'diags_' + dl; |
| return (mod.common$[sel] === undefined |
| ? (Defaults.common$[sel] != Diags.ALWAYS_OFF) |
| : (mod.common$[sel] != Diags.ALWAYS_OFF)); |
| } |
| |
| /* |
| * ======== validate ======== |
| */ |
| function validate() |
| { |
| /* Only process during "cfg" phase */ |
| if (xdc.om.$name != "cfg") { |
| return; |
| } |
| |
| var Diags = xdc.module('xdc.runtime.Diags'); |
| |
| /* |
| * Validate all of the event definitions in all of the modules in the |
| * configuration. |
| */ |
| for (var i = 0; i < xdc.om.$modules.length; i++) { |
| var mod = xdc.om.$modules[i]; |
| |
| /* TODO: check that there's no logger for "impossible" masks */ |
| |
| /* check all Log_Event's declared in any module */ |
| if ('$$logEvtCfgs' in mod && mod.$$logEvtCfgs.length > 0) { |
| for each (var cn in mod.$$logEvtCfgs) { |
| var desc = mod[cn]; |
| |
| if (mod.$used && desc.$private.id == null) { |
| this.$logWarning("The event '" + mod.$name + "." + cn |
| + "' has not been assigned an id. Try adding " |
| + "xdc.useModule('xdc.runtime.Log') to your " |
| + "configuration", mod, cn); |
| } |
| /* check that mask is within UInt16 range */ |
| if (desc.mask < 0) { |
| this.$logError("value of 'mask' must be non-negative", |
| mod, cn); |
| } |
| else if (desc.mask > 0xFFFF) { |
| this.$logError("value of 'mask' must be at most 16 bits", |
| mod, cn); |
| } |
| |
| /* Verify that ASSERT and INTERNAL aren't used in the mask */ |
| if ((desc.mask & Diags.ASSERT) || |
| (desc.mask & Diags.INTERNAL)) { |
| this.$logError("The categories ASSERT and INTERNAL are " + |
| "for asserts only and can not be used for" + |
| " event definitions.", mod, cn); |
| } |
| |
| /* Check that 'level' is within valid range. */ |
| if ((desc.level > Diags.LEVEL4) | (desc.level < Diags.LEVEL1)) { |
| this.$logError("value of 'level' must be between " + |
| "Diags.LEVEL1 and Diags.LEVEL4", mod, cn); |
| } |
| } |
| } |
| } |
| } |