开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
dbdisasm.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：15k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

dbdisasm.c：源码内容
  1. /*******************************************************************************
  2.  *
  3.  * Module Name: dbdisasm - parser op tree display routines
  4.  *              $Revision: 50 $
  5.  *
  6.  ******************************************************************************/
  8. /*
  9.  *  Copyright (C) 2000, 2001 R. Byron Moore
  10.  *
  11.  *  This program is free software; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  *  This program is distributed in the hope that it will be useful,
  17.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  *  GNU General Public License for more details.
  20.  *
  21.  *  You should have received a copy of the GNU General Public License
  22.  *  along with this program; if not, write to the Free Software
  23.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24.  */
  27. #include "acpi.h"
  28. #include "acparser.h"
  29. #include "amlcode.h"
  30. #include "acnamesp.h"
  31. #include "acdebug.h"
  34. #ifdef ENABLE_DEBUGGER
  36. #define _COMPONENT          ACPI_DEBUGGER
  37.  MODULE_NAME         ("dbdisasm")
  40. #define MAX_SHOW_ENTRY      128
  41. #define BLOCK_PAREN         1
  42. #define BLOCK_BRACE         2
  43. #define DB_NO_OP_INFO       "            [%2.2d]  "
  44. #define DB_FULL_OP_INFO     "%5.5X #%4.4X [%2.2d]  "
  47. NATIVE_CHAR                 *acpi_gbl_db_disasm_indent = "....";
  50. /*******************************************************************************
  51.  *
  52.  * FUNCTION:    Acpi_db_block_type
  53.  *
  54.  * PARAMETERS:  Op              - Object to be examined
  55.  *
  56.  * RETURN:      Status
  57.  *
  58.  * DESCRIPTION: Type of block for this op (parens or braces)
  59.  *
  60.  ******************************************************************************/
  62. u32
  63. acpi_db_block_type (
  64. acpi_parse_object       *op)
  65. {
  67. switch (op->opcode) {
  68. case AML_METHOD_OP:
  69. return (BLOCK_BRACE);
  70. break;
  72. default:
  73. break;
  74. }
  76. return (BLOCK_PAREN);
  78. }
  81. /*******************************************************************************
  82.  *
  83.  * FUNCTION:    Acpi_ps_display_object_pathname
  84.  *
  85.  * PARAMETERS:  Op              - Object whose pathname is to be obtained
  86.  *
  87.  * RETURN:      Status
  88.  *
  89.  * DESCRIPTION: Diplay the pathname associated with a named object.  Two
  90.  *              versions. One searches the parse tree (for parser-only
  91.  *              applications suchas Acpi_dump), and the other searches the
  92.  *              ACPI namespace (the parse tree is probably deleted)
  93.  *
  94.  ******************************************************************************/
  96. #ifdef PARSER_ONLY
  98. acpi_status
  99. acpi_ps_display_object_pathname (
  100. acpi_walk_state         *walk_state,
  101. acpi_parse_object       *op)
  102. {
  103. acpi_parse_object       *target_op;
  106. /* Search parent tree up to the root if necessary */
  108. target_op = acpi_ps_find (op, op->value.name, 0, 0);
  109. if (!target_op) {
  110. /*
  111.  * Didn't find the name in the parse tree.  This may be
  112.  * a problem, or it may simply be one of the predefined names
  113.  * (such as _OS_).  Rather than worry about looking up all
  114.  * the predefined names, just display the name as given
  115.  */
  116. acpi_os_printf (" **** Path not found in parse tree");
  117. }
  119. else {
  120. /* The target was found, print the name and complete path */
  122. acpi_os_printf (" (Path ");
  123. acpi_db_display_path (target_op);
  124. acpi_os_printf (")");
  125. }
  127. return (AE_OK);
  128. }
  130. #else
  132. acpi_status
  133. acpi_ps_display_object_pathname (
  134. acpi_walk_state         *walk_state,
  135. acpi_parse_object       *op)
  136. {
  137. acpi_status             status;
  138. acpi_namespace_node     *node;
  139. NATIVE_CHAR             buffer[MAX_SHOW_ENTRY];
  140. u32                     buffer_size = MAX_SHOW_ENTRY;
  141. u32                     debug_level;
  144. /* Save current debug level so we don't get extraneous debug output */
  146. debug_level = acpi_dbg_level;
  147. acpi_dbg_level = 0;
  149. /* Just get the Node out of the Op object */
  151. node = op->node;
  152. if (!node) {
  153. /* Node not defined in this scope, look it up */
  155. status = acpi_ns_lookup (walk_state->scope_info, op->value.string, ACPI_TYPE_ANY,
  156.   IMODE_EXECUTE, NS_SEARCH_PARENT, walk_state, &(node));
  158. if (ACPI_FAILURE (status)) {
  159. /*
  160.  * We can't get the pathname since the object
  161.  * is not in the namespace.  This can happen during single
  162.  * stepping where a dynamic named object is *about* to be created.
  163.  */
  164. acpi_os_printf (" [Path not found]");
  165. goto exit;
  166. }
  168. /* Save it for next time. */
  170. op->node = node;
  171. }
  173. /* Convert Named_desc/handle to a full pathname */
  175. status = acpi_ns_handle_to_pathname (node, &buffer_size, buffer);
  176. if (ACPI_FAILURE (status)) {
  177. acpi_os_printf ("****Could not get pathname****)");
  178. goto exit;
  179. }
  181. acpi_os_printf (" (Path %s)", buffer);
  184. exit:
  185. /* Restore the debug level */
  187. acpi_dbg_level = debug_level;
  188. return (status);
  189. }
  191. #endif
  194. /*******************************************************************************
  195.  *
  196.  * FUNCTION:    Acpi_db_display_op
  197.  *
  198.  * PARAMETERS:  Origin          - Starting object
  199.  *              Num_opcodes     - Max number of opcodes to be displayed
  200.  *
  201.  * RETURN:      None
  202.  *
  203.  * DESCRIPTION: Display parser object and its children
  204.  *
  205.  ******************************************************************************/
  207. void
  208. acpi_db_display_op (
  209. acpi_walk_state         *walk_state,
  210. acpi_parse_object       *origin,
  211. u32                     num_opcodes)
  212. {
  213. acpi_parse_object       *op = origin;
  214. acpi_parse_object       *arg;
  215. acpi_parse_object       *depth;
  216. u32                     depth_count = 0;
  217. u32                     last_depth = 0;
  218. u32                     i;
  219. u32                     j;
  222. if (op) {
  223. while (op) {
  224. /* indentation */
  226. depth_count = 0;
  227. if (!acpi_gbl_db_opt_verbose) {
  228. depth_count++;
  229. }
  231. /* Determine the nesting depth of this argument */
  233. for (depth = op->parent; depth; depth = depth->parent) {
  234. arg = acpi_ps_get_arg (depth, 0);
  235. while (arg && arg != origin) {
  236. arg = arg->next;
  237. }
  239. if (arg) {
  240. break;
  241. }
  243. depth_count++;
  244. }
  247. /* Open a new block if we are nested further than last time */
  249. if (depth_count > last_depth) {
  250. VERBOSE_PRINT ((DB_NO_OP_INFO, last_depth));
  251. for (i = 0; i < last_depth; i++) {
  252. acpi_os_printf ("%s", acpi_gbl_db_disasm_indent);
  253. }
  255. if (acpi_db_block_type (op) == BLOCK_PAREN) {
  256. acpi_os_printf ("(n");
  257. }
  258. else {
  259. acpi_os_printf ("{n");
  260. }
  261. }
  263. /* Close a block if we are nested less than last time */
  265. else if (depth_count < last_depth) {
  266. for (j = 0; j < (last_depth - depth_count); j++) {
  267. VERBOSE_PRINT ((DB_NO_OP_INFO, last_depth - j));
  268. for (i = 0; i < (last_depth - j - 1); i++) {
  269. acpi_os_printf ("%s", acpi_gbl_db_disasm_indent);
  270. }
  272. if (acpi_db_block_type (op) == BLOCK_PAREN) {
  273. acpi_os_printf (")n");
  274. }
  275. else {
  276. acpi_os_printf ("}n");
  277. }
  278. }
  279. }
  281. /* In verbose mode, print the AML offset, opcode and depth count */
  283. VERBOSE_PRINT ((DB_FULL_OP_INFO, (unsigned) op->aml_offset, op->opcode, depth_count));
  286. /* Indent the output according to the depth count */
  288. for (i = 0; i < depth_count; i++) {
  289. acpi_os_printf ("%s", acpi_gbl_db_disasm_indent);
  290. }
  293. /* Now print the opcode */
  295. acpi_db_display_opcode (walk_state, op);
  297. /* Resolve a name reference */
  299. if ((op->opcode == AML_INT_NAMEPATH_OP && op->value.name)  &&
  300. (op->parent) &&
  301. (acpi_gbl_db_opt_verbose)) {
  302. acpi_ps_display_object_pathname (walk_state, op);
  303. }
  305. acpi_os_printf ("n");
  307. /* Get the next node in the tree */
  309. op = acpi_ps_get_depth_next (origin, op);
  310. last_depth = depth_count;
  312. num_opcodes--;
  313. if (!num_opcodes) {
  314. op = NULL;
  315. }
  316. }
  318. /* Close the last block(s) */
  320. depth_count = last_depth -1;
  321. for (i = 0; i < last_depth; i++) {
  322. VERBOSE_PRINT ((DB_NO_OP_INFO, last_depth - i));
  323. for (j = 0; j < depth_count; j++) {
  324. acpi_os_printf ("%s", acpi_gbl_db_disasm_indent);
  325. }
  326. acpi_os_printf ("}n");
  327. depth_count--;
  328. }
  330. }
  332. else {
  333. acpi_db_display_opcode (walk_state, op);
  334. }
  335. }
  338. /*******************************************************************************
  339.  *
  340.  * FUNCTION:    Acpi_db_display_namestring
  341.  *
  342.  * PARAMETERS:  Name                - ACPI Name string to store
  343.  *
  344.  * RETURN:      None
  345.  *
  346.  * DESCRIPTION: Display namestring. Handles prefix characters
  347.  *
  348.  ******************************************************************************/
  350. void
  351. acpi_db_display_namestring (
  352. NATIVE_CHAR             *name)
  353. {
  354. u32                     seg_count;
  355. u8                      do_dot = FALSE;
  358. if (!name) {
  359. acpi_os_printf ("<NULL NAME PTR>");
  360. return;
  361. }
  363. if (acpi_ps_is_prefix_char (GET8 (name))) {
  364. /* append prefix character */
  366. acpi_os_printf ("%1c", GET8 (name));
  367. name++;
  368. }
  370. switch (GET8 (name)) {
  371. case AML_DUAL_NAME_PREFIX:
  372. seg_count = 2;
  373. name++;
  374. break;
  376. case AML_MULTI_NAME_PREFIX_OP:
  377. seg_count = (u32) GET8 (name + 1);
  378. name += 2;
  379. break;
  381. default:
  382. seg_count = 1;
  383. break;
  384. }
  386. while (seg_count--) {
  387. /* append Name segment */
  389. if (do_dot) {
  390. /* append dot */
  392. acpi_os_printf (".");
  393. }
  395. acpi_os_printf ("%4.4s", name);
  396. do_dot = TRUE;
  398. name += 4;
  399. }
  400. }
  403. /*******************************************************************************
  404.  *
  405.  * FUNCTION:    Acpi_db_display_path
  406.  *
  407.  * PARAMETERS:  Op                  - Named Op whose path is to be constructed
  408.  *
  409.  * RETURN:      None
  410.  *
  411.  * DESCRIPTION: Walk backwards from current scope and display the name
  412.  *              of each previous level of scope up to the root scope
  413.  *              (like "pwd" does with file systems)
  414.  *
  415.  ******************************************************************************/
  417. void
  418. acpi_db_display_path (
  419. acpi_parse_object       *op)
  420. {
  421. acpi_parse_object       *prev;
  422. acpi_parse_object       *search;
  423. u32                     name;
  424. u8                      do_dot = FALSE;
  425. acpi_parse_object       *name_path;
  426. const acpi_opcode_info  *op_info;
  429. /* We are only interested in named objects */
  431. op_info = acpi_ps_get_opcode_info (op->opcode);
  432. if (!(op_info->flags & AML_NSNODE)) {
  433. return;
  434. }
  437. if (op_info->flags & AML_CREATE) {
  438. /* Field creation - check for a fully qualified namepath */
  440. if (op->opcode == AML_CREATE_FIELD_OP) {
  441. name_path = acpi_ps_get_arg (op, 3);
  442. }
  443. else {
  444. name_path = acpi_ps_get_arg (op, 2);
  445. }
  447. if ((name_path) &&
  448. (name_path->value.string) &&
  449. (name_path->value.string[0] == '\')) {
  450. acpi_db_display_namestring (name_path->value.string);
  451. return;
  452. }
  453. }
  455. prev = NULL;            /* Start with Root Node */
  457. while (prev != op) {
  458. /* Search upwards in the tree to find scope with "prev" as its parent */
  460. search = op;
  461. for (; ;) {
  462. if (search->parent == prev) {
  463. break;
  464. }
  466. /* Go up one level */
  468. search = search->parent;
  469. }
  471. if (prev) {
  472. op_info = acpi_ps_get_opcode_info (search->opcode);
  473. if (!(op_info->flags & AML_FIELD)) {
  474. /* below root scope, append scope name */
  476. if (do_dot) {
  477. /* append dot */
  479. acpi_os_printf (".");
  480. }
  482. if (op_info->flags & AML_CREATE) {
  483. if (op->opcode == AML_CREATE_FIELD_OP) {
  484. name_path = acpi_ps_get_arg (op, 3);
  485. }
  486. else {
  487. name_path = acpi_ps_get_arg (op, 2);
  488. }
  490. if ((name_path) &&
  491. (name_path->value.string)) {
  492. acpi_os_printf ("%4.4s", name_path->value.string);
  493. }
  494. }
  496. else {
  497. name = acpi_ps_get_name (search);
  498. acpi_os_printf ("%4.4s", &name);
  499. }
  501. do_dot = TRUE;
  502. }
  503. }
  505. prev = search;
  506. }
  507. }
  510. /*******************************************************************************
  511.  *
  512.  * FUNCTION:    Acpi_db_display_opcode
  513.  *
  514.  * PARAMETERS:  Op                  - Op that is to be printed
  515.  *
  516.  * RETURN:      Status
  517.  *
  518.  * DESCRIPTION: Store printed op in a Buffer and return its length
  519.  *              (or -1 if out of space)
  520.  *
  521.  * NOTE: Terse mode prints out ASL-like code.  Verbose mode adds more info.
  522.  *
  523.  ******************************************************************************/
  525. void
  526. acpi_db_display_opcode (
  527. acpi_walk_state         *walk_state,
  528. acpi_parse_object       *op)
  529. {
  530. u8                      *byte_data;
  531. u32                     byte_count;
  532. u32                     i;
  533. const acpi_opcode_info  *op_info = NULL;
  534. u32                     name;
  537. if (!op) {
  538. acpi_os_printf ("<NULL OP PTR>");
  539. }
  542. /* op and arguments */
  544. switch (op->opcode) {
  546. case AML_BYTE_OP:
  548. if (acpi_gbl_db_opt_verbose) {
  549. acpi_os_printf ("(u8) 0x%2.2X", op->value.integer8);
  550. }
  552. else {
  553. acpi_os_printf ("0x%2.2X", op->value.integer8);
  554. }
  556. break;
  559. case AML_WORD_OP:
  561. if (acpi_gbl_db_opt_verbose) {
  562. acpi_os_printf ("(u16) 0x%4.4X", op->value.integer16);
  563. }
  565. else {
  566. acpi_os_printf ("0x%4.4X", op->value.integer16);
  567. }
  569. break;
  572. case AML_DWORD_OP:
  574. if (acpi_gbl_db_opt_verbose) {
  575. acpi_os_printf ("(u32) 0x%8.8X", op->value.integer32);
  576. }
  578. else {
  579. acpi_os_printf ("0x%8.8X", op->value.integer32);
  580. }
  582. break;
  585. case AML_QWORD_OP:
  587. if (acpi_gbl_db_opt_verbose) {
  588. acpi_os_printf ("(u64) 0x%8.8X%8.8X", op->value.integer64.hi,
  589.  op->value.integer64.lo);
  590. }
  592. else {
  593. acpi_os_printf ("0x%8.8X%8.8X", op->value.integer64.hi,
  594.  op->value.integer64.lo);
  595. }
  597. break;
  600. case AML_STRING_OP:
  602. if (op->value.string) {
  603. acpi_os_printf (""%s"", op->value.string);
  604. }
  606. else {
  607. acpi_os_printf ("<"NULL STRING PTR">");
  608. }
  610. break;
  613. case AML_INT_STATICSTRING_OP:
  615. if (op->value.string) {
  616. acpi_os_printf (""%s"", op->value.string);
  617. }
  619. else {
  620. acpi_os_printf (""<NULL STATIC STRING PTR>"");
  621. }
  623. break;
  626. case AML_INT_NAMEPATH_OP:
  628. acpi_db_display_namestring (op->value.name);
  629. break;
  632. case AML_INT_NAMEDFIELD_OP:
  634. acpi_os_printf ("Named_field (Length 0x%8.8X)  ", op->value.integer32);
  635. break;
  638. case AML_INT_RESERVEDFIELD_OP:
  640. acpi_os_printf ("Reserved_field (Length 0x%8.8X) ", op->value.integer32);
  641. break;
  644. case AML_INT_ACCESSFIELD_OP:
  646. acpi_os_printf ("Access_field (Length 0x%8.8X) ", op->value.integer32);
  647. break;
  650. case AML_INT_BYTELIST_OP:
  652. if (acpi_gbl_db_opt_verbose) {
  653. acpi_os_printf ("Byte_list   (Length 0x%8.8X)  ", op->value.integer32);
  654. }
  656. else {
  657. acpi_os_printf ("0x%2.2X", op->value.integer32);
  659. byte_count = op->value.integer32;
  660. byte_data = ((acpi_parse2_object *) op)->data;
  662. for (i = 0; i < byte_count; i++) {
  663. acpi_os_printf (", 0x%2.2X", byte_data[i]);
  664. }
  665. }
  667. break;
  670. default:
  672. /* Just get the opcode name and print it */
  674. op_info = acpi_ps_get_opcode_info (op->opcode);
  675. acpi_os_printf ("%s", op_info->name);
  678. #ifndef PARSER_ONLY
  679. if ((op->opcode == AML_INT_RETURN_VALUE_OP) &&
  680. (walk_state->results) &&
  681. (walk_state->results->results.num_results)) {
  682. acpi_db_decode_internal_object (walk_state->results->results.obj_desc [walk_state->results->results.num_results-1]);
  683. }
  684. #endif
  686. break;
  687. }
  689. if (!op_info) {
  690. /* If there is another element in the list, add a comma */
  692. if (op->next) {
  693. acpi_os_printf (",");
  694. }
  695. }
  697. /*
  698.  * If this is a named opcode, print the associated name value
  699.  */
  700. op_info = acpi_ps_get_opcode_info (op->opcode);
  701. if (op && (op_info->flags & AML_NAMED)) {
  702. name = acpi_ps_get_name (op);
  703. acpi_os_printf (" %4.4s", &name);
  705. if (acpi_gbl_db_opt_verbose) {
  706. acpi_os_printf (" (Path \");
  707. acpi_db_display_path (op);
  708. acpi_os_printf (")");
  709. }
  710. }
  711. }
  714. #endif  /* ENABLE_DEBUGGER */