CCS/TM4C1290NCPDT: Embedding a different firmware image as a binary resource

I have figured out how to do this and will give general instructions below. They should work for any arbitrary binary file.

Step 1 - Prepare your binary resource file.

How you do this is beyond the scope of these instructions. Whatever you end up with will become an exact image
copied into the program flash of the ARM processor. For this example it will be named BinaryFile.bin

Step 2 - Create an ELF file from the binary file using GCC objcopy command

arm-none-eabi-objcopy --input-target=binary -B arm --output-target=elf32-littlearm --rename-section .data=.image,alloc,load,readonly,data,contents BinaryFile.bin BinaryFile.out

Here the options --input-target=binary and --output-target=elf32-littlearm specify the input and output file formats.
-B arm says you are doing a binary to object resource conversion, and specifies the architecture of the ELF file
--rename-section .data=.image,alloc,load,readonly,data,contents does two things:

By default the binary object created will be placed in a section named .data. Using this option allows you to place the new resource into a separate section so it will not be linked together with other resources. In this case the new section is named .image.
Adding the section flags "alloc,load,readonly,data,contents" will make the new section a read only section, that is allocated space in your final program image, and will have the binary data copied into your final executable.

Step 3 - Edit the .out file to have the correct ELF e_flags value

Open up the BinaryFile.out file in a binary (hex) editor. Change the value of byte 0x27 from 00 to 05.
This will allow the ccs linker to accept the ELF file, otherwise it generates an error.

This step is the only one that is not really documented anywhere. The number 5 came from a ccs error message.

Alternatively, as suggested by Chester Gillon,  add --diag_warning=16006 to the linker options; under CCS Build -> ARM Linker -> Advanced Options -> Diagnostics add 16006 to "Treat diagnostic <id> as warning (--diag_warning)". This changes diagnostic 16006 from a linker error to a warning, to allow the program to link.

Step 4 - Add the .out file to your project

(These are the instructions for ccs9)
Place the BinaryFile.out file in the project folder.
Open up the project options and navigate to the CCS Build > File Search Path controls
under the "Include library file or command file as input", add the BinaryFile.out file.
(Hint, click "Add..." then click on "Workspace..." then navigate to the file. This will use build variables
to locate the file instead of an absolute file path.)

Step 5 - Add the new section to your linker command file

You will need to add the new section(s) created in step 2 into your liker command file so the linker will know where to put them in memory. If you are using a default linker script, copy it into your project so you can edit it, and change the linker command script used in the linker project settings. Then add the highlighted line to the SECTIONS section:

SECTIONS
{
    .intvecs:   > 0x00000000
    .text   :   > FLASH
    .const  :   > FLASH
    .cinit  :   > FLASH
    .pinit  :   > FLASH
    .image  :   > FLASH  /* Add this line using your section name */
    .init_array : > FLASH

    .vtable :   > 0x20000000
    .data   :   > SRAM
    .bss    :   > SRAM
    .sysmem :   > SRAM
    .stack  :   > SRAM
}

Step 6 - Use the resource in your code

When you create the ELF file in step 2, three linker symbols are created that allow you to access the data:
_binary_BinaryFile_bin_start (holds the starting address of the binary resource)
_binary_BinaryFile_bin_end   (holds the ending address of the binary resource)
_binary_BinaryFile_bin_size  (holds the size of the binary resource)

The _start, and _end values are relocatable, so the final linking process will give these variables the location that the
resource ends up in the final build.

Note: The variable names are based on the name of the binary file used in step 1.

_binary_<file name>_start  etc.

Since these are linker generated variables, they work slightly differently from normal C variables

Declare them in a header file, or at file scope with:

extern const uint8_t * _binary_BinaryFile_RGZ_bin_start;
extern const uint8_t * _binary_BinaryFile_RGZ_bin_end;
extern const uint8_t * _binary_BinaryFile_bin_size;

The easiest way to use them is to assign the values to regular C variable like this:

int size = &_binary_BinaryFile_RGZ_bin_size;
const uint8_t * ptr = &_binary_BinaryFile_RGZ_bin_start;

Now you can do things like:

for (i=0; i<size; i++)
{
   printf("%02X ", ptr[i]);
}

I hope this is helpful.