Saltar al contenido principal
LibreTexts Español

2.2: Advertencias del lenguaje ensamblador

  • Page ID
    80630
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    \( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

    ( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\id}{\mathrm{id}}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\kernel}{\mathrm{null}\,}\)

    \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\)

    \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\)

    \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    \( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

    \( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

    \( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vectorC}[1]{\textbf{#1}} \)

    \( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

    \( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

    \( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

    \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    Los programadores que han aprendido lenguaje de nivel superior, como Java, C/C++, C# o Ada, a menudo han desarrollado formas de pensar sobre un programa que son inapropiadas para lenguajes y sistemas de bajo nivel como el lenguaje ensamblador. Esta sección dará algunas sugerencias a los programadores que se acerquen por primera vez al lenguaje ensamblador.

    Lo primero a considerar es que todas las instrucciones deben implementar operaciones primitivas. Los idiomas de nivel superior permiten una mano corta que implica muchas instrucciones. Por ejemplo, la sentencia B=A+5 implica operaciones de carga que preparan las variables A y 5 para ser enviadas a la ALU. A continuación se va a realizar una operación de adición por parte de la ALU. Finalmente, es necesario ejecutar una operación para almacenar el resultado de la ALU de nuevo en la variable B. En el montaje el programador debe especificar todas las operaciones primitivas necesarias. No hay atajos.

    Lo segundo a considerar es que a pesar de que lo que podrías haber escuchado acerca de que las declaraciones goto son malas, no hay forma de implementar el control de programas como sentencias if o loops sin usar una instrucción de rama, que es el equivalente a una declaración goto. Esto no significa que los constructos de programación estructurada no puedan ser utilizados de manera efectiva. Si un programa se confunde acerca de cómo implementar construcciones de programación estructurada en asamblea, hay un capítulo en un libro gratuito sobre el programa de montaje MIPS escrito por el autor de esta monografía que explica cómo esto se puede lograr.

    El tercer punto importante sobre el lenguaje ensamblador es que los datos no tienen contexto. En un lenguaje de nivel superior normalmente las variables A y B, y el número 5, se especifican como enteros. El lenguaje de nivel superior sabe que estos son enteros, y luego proporciona un contexto para interpretarlos. Se sabe que la operación add es una suma entera, y el compilador generará una instrucción para hacer la opción integer y no una operación de punto flotante. Si la declaración de los números se cambiara a float, la operación add en el lenguaje de nivel superior se cambiaría a una suma de punto flotante. El lenguaje de nivel superior conoce las variables de tipo, y puede proporcionar el contexto adecuado para interpretarlas.

    En lenguaje ensamblador, no hay contexto para ningún dato. Los datos pueden ser un entero, un valor booleano, un número de coma flotante, caracteres ASCII o incluso instrucciones de programa. El ensamblador no tiene idea de un tipo, y simplemente ejecutará la operación especificada. Es posible en el montaje realizar operaciones sin sentido, como agregar dos instrucciones de programa juntas. El lenguaje ensamblador con mucho gusto te permitirá hacer cosas sin sentido y completamente inanas, y de ninguna manera te advertirá que no tiene sentido. El ensamblador no tiene contexto para los datos, y no hay forma de corregir este problema porque desde el punto de vista del ensamblador, no hay problema.

    Al programar en lenguaje ensamblador, es importante que el programador mantenga conocimiento del contexto actual del programa. Es el programador quien sabe si dos elementos de datos son enteros, y por lo tanto es apropiada una operación de suma de enteros. Depende del programador estar al tanto de si los valores con los que se trabaja son direcciones o valores, y hacer las operaciones de desreferenciación adecuadas. No hay nada más que el conocimiento del programador para asegurar que un programa ejecutará operaciones correctas en los tipos de datos adecuados.


    This page titled 2.2: Advertencias del lenguaje ensamblador is shared under a CC BY 4.0 license and was authored, remixed, and/or curated by Charles W. Kann III via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.