Jump to content

High Level Assembly

From Wikipedia, the free encyclopedia
This article is about a particular high-level assembly language. For the general concept, see High-level assembler.
High Level Assembly (HLA)
Developer(s)Randall Hyde
Stable release
2.16 / July 6, 2011; 13 years ago (2011-07-06)
Repositorysourceforge.net/projects/hlav1
Written inAssembly language
Operating systemWindows, Linux, FreeBSD, macOS
PlatformIA-32
Available inEnglish
TypeAssembler
LicensePublic domain
Websiteplantation-productions.com/Webster/HighLevelAsm/index.html

High-Level Assembly (HLA) is a language developed by Randall Hyde that enables the use of higher-level language constructs to aid both novice and experienced assembly developers. It supports advanced data types and object-oriented programming. Its syntax is loosely based on several high-level programming languages (HLLs), such as Pascal, Ada, Modula-2, and C++, to facilitate the creation of readable assembly language programs and enable HLL programmers to learn HLA quickly.

Origins and Goals

[edit]

HLA was initially designed as a tool for teaching assembly language programming at the college and university level. The objective was to leverage students' existing programming knowledge to accelerate their learning of assembly language. Most students in assembly language programming courses are already familiar with high-level control flow structures like IF, WHILE, and FOR. HLA allows students to immediately apply this knowledge to assembly language coding early in the course. This enables them to master other prerequisite subjects in assembly before learning how to code low-level forms of these control structures. The book The Art of Assembly Language Programming by Randall Hyde utilizes HLA for this purpose.[1]

High vs. low-level assembler

[edit]

HLA v2.x supports the same low-level machine instructions as a regular low-level assembler. High-end assemblers also support high-level-language-like statements (such as IF and WHILE) and more advanced data declaration directives, including structures-records, unions, and even classes.

Examples of high-end assemblers include HLA, Microsoft Macro Assembler (MASM), and Turbo Assembler (TASM) on the Intel x86 processor family.

Unlike most other assembler tools, the HLA compiler includes a Standard Library with thousands of functions, proceduress and macross that can be used to create full applications with the ease of a high-level language. While assembly language libraries are not new, a language that includes a large standardized library encourages programmers to use library code rather than writing their own functions.

HLA supports all the same low-level machine instructions as other x86 assemblers. Furthermore, HLA's high-level control structures are based on those found in MASM and TASM, whose HLL-like features predated HLA by several years. In HLA, low-level assembly code can be written just as easily as with any other assembler by ignoring the HLL control constructs. Unlike HLLs like Pascal and C(++), HLA does not require inline asm statements. HLA's HLL-like features provide a learning aid for beginning assembly programmers by easing the learning curve, with the expectation that they will discontinue using those statements once they master the low-level instruction set. In practice, many experienced programmers continue to use HLL-like statements in HLA, MASM, and TASM long after mastering the low-level instruction set, typically to improve readability.

It is also possible to write high-level programs using HLA, which reduces the tedium of low-level assembly language programming. Some assembly language programmers reject HLA outright[citation needed] because it allows programmers to do this. However, supporting both high-level and low-level programming gives any language a broader range of applicability.

Distinguishing features

[edit]

Two HLA features distinguish it from other x86 assemblers: its powerful macro system (compile-time language) and the HLA Standard Library.

Macro system

[edit]

HLA's compile-time language allows easy extension of the language, even enabling the creation of small domain-specific languages to simplify common programming problems. The macro stdout.put is a good example of a sophisticated macro that can simplify programming. Consider the following invocation of that macro:

stdout.put( "I=", i, " s=", s, " u=", u, " r=", r:10:2, nl );

The stdout.put macro processes each argument to determine its type and then calls an appropriate procedure in the HLA Standard Library to handle the output of each operand.

Most assemblers offer some macro capabilities. HLA's advantage over other assemblers is its ability to process macro arguments like r:10:2 using HLA's extensive compile-time string functions. HLA's macro facilities can also infer variable types and use that information to direct macro expansion.

HLA's macro language provides a special Context-Free macro facility. This feature allows easy writing of macros that span other code sections via a starting and terminating macro pair (along with optional intermediate macro invocations available only between the start–terminate macros). For example, one can write a fully recursive-nestable SWITCH–CASE–DEFAULT–ENDSWITCH statement using this macro facility.

Because of the HLA macro facilities' context-free design, these switch..case..default..endswitch statements can be nested without conflicting code emission.

Compile-Time Language

[edit]

The HLA macro system is a subset of the larger HLA Compile-Time Language (CTL). The HLA CTL is an interpreted language available within an HLA program source file; hence the name compile-time language.

The HLA CTL includes control statements such as #IF, #WHILE, #FOR, #PRINT, and an assignment statement. One can also create compile-time variables and constants, including structured data types like records and unions. The HLA CTL also provides hundreds of built-in functions, including a rich set of string and pattern-matching functions. The HLA CTL allows programmers to create CTL programs that scan and parse strings, enabling the creation of embedded domain-specific languages (EDSLs, also termed mini-languages). The stdout.put macro mentioned earlier is an example of such an EDSL. The put macro (in the stdout namespace, hence stdout.put) parses its macro parameter list and emits the code that will print its operands.

Standard library

[edit]

The HLA Standard Library is an extensive collection of pre-made routines and macros (like the stdout.put macro described above) that simplify programming by preventing programmers from starting from scratch for each new application. Perhaps equally important, the HLA Standard Library allows programmers to write portable applications that run under Windows or Linux by simply recompiling the source code. Similar to the C standard library for the programming language C, the HLA Standard Library allows users to abstract away low-level operating system (OS) calls, so the same set of OS application programming interfaces (APIs) can serve for all operating systems that HLA supports. While an assembly language allows making any needed OS calls, using the HLA Standard Library API set simplifies writing OS-portable programs.

The HLA Standard Library provides thousands of functions, procedures, and macros. As of mid-2010 for HLA v2.12, the library included functions in these categories (though the list changes over time):

  • Command-line argument processing
  • Array (dynamic) declaration and manipulation
  • Bit manipulation
  • Blob (binary large object) manipulation
  • Character manipulation
  • Conversions
  • Character set manipulation
  • Date and time functions
  • Object-oriented file I/O
  • Standard file I/O
  • File system manipulation functions, e.g., delete, rename, change directory
  • HLA-related declarations and functions
  • The HLA Object Windows Library: object-oriented framework for Win32 programming
  • Linked list manipulation
  • Mathematical functions
  • Memory allocation and management
  • FreeBSD-specific APIs
  • Linux-specific APIs
  • MacOS-specific APIs
  • Win32-specific APIs
  • Text console functions
  • Coroutine support
  • Environment variable support
  • Exception handling support
  • Memory-mapped file support
  • Sockets and client–server object support
  • Thread and synchronization support
  • Timer functions
  • Pattern matching support for regular expressions and context-free languages
  • Random number generators
  • Remote procedure call support
  • Standard error output functions
  • Standard output functions
  • Standard input functions
  • String functions
  • Table (associative) support
  • Zero-terminated string functions

Design

[edit]

The HLA v2.x language system is a command-line driven tool that consists of several components, including a shell program (e.g., hla.exe under Windows), the HLA language compiler (e.g., hlaparse.exe), a low-level translator (e.g., the HLABE, or HLA Back Engine), a linker (link.exe under Windows, ld under Linux), and other tools such as a resource compiler for Windows. Versions before 2.0 relied on an external assembler back end; versions 2.x and later of HLA use the built-in HLABE as the back-end object code formatter.

The HLA shell application processes command line parameters and routes appropriate files to each program in the HLA system. It accepts .hla files (HLA source files), .asm files (source files for MASM, TASM, FASM, NASM, or Gas assemblers), .obj files for input to the linker, and .rc files (for use by a resource compiler).

Source code translation

[edit]

Originally, the HLA v1.x tool compiled its source code into an intermediate source file that a back-end assembler such as MASM, TASM, flat assembler (FASM), Netwide Assembler (NASM), or GNU Assembler (Gas) would translate into the low-level object code file. As of HLA v2.0, HLA included its own HLA Back Engine (HLABE) that provided the low-level object code translation. However, via various command-line parameters, HLA v2.x can still translate an HLA source file into a source file compatible with one of these other assemblers.

HLA Back Engine

[edit]

The HLA Back Engine (HLABE) is a compiler back end that translates an internal intermediate language into low-level Portable Executable (PE), Common Object File Format (COFF), Executable and Linkable Format (ELF), or Mach-O object code. An HLABE program mainly consists of data (byte) emission statements, 32-bit relocatable address statements, x86 control-transfer instructions, and various directives. In addition to translating byte and relocatable address statements into the low-level object code format, HLABE also handles branch-displacement optimization (picking the shortest possible form of a branch instruction).

Although the HLABE is incorporated into the HLA v2.x compiler, it is a separate product. It is public domain and open source (hosted on SourceForge.net).

See also

[edit]

Notes

[edit]
  1. ^ "The Art of Assembly Language Programming". Archived from the original on 2018-03-29. Retrieved 2010-02-12.

References

[edit]

Further reading

[edit]
[edit]
Retrieved from "https://en.wikipedia.org/w/index.php?title=High_Level_Assembly&oldid=1283160104"