/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU Lesser General Public License for more details.
* 
* You should have received a copy of the GNU Lesser General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <iostream>
#include "dwarfmanager.h"
#include "inputfile.h"

const string DwarfLineManager::iLineSectionName(".debug_line");

inline static size_t process_extended_line_op (FileShdrPair & aPair, Dwarf_Byte_Ptr data)
{
	size_t bytes_read;
	size_t len = (size_t)ULEB128(data, bytes_read);

	if (len == 0){
		cerr << "badly formed extended line op encountered!\n";
		// a length of 0 indicates a badly formed op and will force everything to be ignored until 'end_of_sequence'.
		return 0;
	}

	len += bytes_read;
	unsigned char op_code = *data++;
  	switch (op_code){
    case DW_LNE_end_sequence:
      	break;
    case DW_LNE_set_address: {
    	size_t size = len - bytes_read - 1;
		LinearAddr addr = GetValue(data, size);
		LinearAddr relocatedAddress = aPair.iXIPFileDetails.Relocate(addr);
		if (addr != relocatedAddress)
			WriteValue(data, relocatedAddress, size);
		break;
    	}
    case DW_LNE_define_file:
      	ULEB128(data, bytes_read);
      	ULEB128(data, bytes_read);
      	ULEB128(data, bytes_read);
      	break;     
    default:

    	break;
    }

  return len;
}

void DwarfLineManager::ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr aStart, Dwarf_Byte_Ptr aEnd){
	Dwarf_Byte_Ptr start = aStart;
	Dwarf_Byte_Ptr end = aEnd;
	size_t bytes_read = 0;
	while (start < end){
		Dwarf_Byte_Ptr hdrptr = start;		
		size_t offset_size, initial_length_size;
		
		Dwarf_Word length = READ_UNALIGNED4(hdrptr); 
		hdrptr += 4;

		if (length >= 0xfffffff0u) {
			cerr << "Error: 64 bit DWARF not supported\n";
			exit(EXIT_FAILURE);
		} else {	
			offset_size = 4;
			initial_length_size = 4;
		}
		
		Dwarf_Byte_Ptr end_of_sequence = start + length + initial_length_size;

		Dwarf_Half version = READ_UNALIGNED2(hdrptr);
		hdrptr += 2;

		if (version != 2 && version != 3){
			static bool warned = false;
			if (!warned){
				cerr << "Only DWARF 2 and 3 aranges are currently supported\n";
				warned = true;
			}
			return;
		}
		
		hdrptr += offset_size;
#if 0
		// Don't need the next four fields 
		Dwarf_Ubyte min_insn_length = *hdrptr++;   
		Dwarf_Ubyte default_is_stmt = *hdrptr++;
		Dwarf_Ubyte line_base = *hdrptr++;
		Dwarf_Ubyte line_range = *hdrptr++;
#endif
		hdrptr +=4;
		Dwarf_Ubyte opcode_base = *hdrptr++;

	    /* Skip the contents of the Opcodes table.  */
		Dwarf_Byte_Ptr standard_opcodes = hdrptr;
		start = standard_opcodes + opcode_base - 1;

		/* skip the contents of the Directory table.  */
		while (*start != 0){
			start += strlen ((char *) start) + 1;
		}
		/* Skip the NUL at the end of the table.  */
		start++;

		/* skip the contents of the File Name table.  */
		while (*start != 0){
			start += strlen ((char *) start) + 1;

			ULEB128(start, bytes_read);
			ULEB128(start, bytes_read);
			ULEB128(start, bytes_read);
		}
		/* Skip the NUL at the end of the table.  */
		start++;
	   
		while (start < end_of_sequence){
			unsigned char op_code = *start++;

			if (op_code >= opcode_base){
				continue;
			} else {
				switch (op_code){
// missing from dwarf.h - first byte of extended op codes is '0x0'
#define DW_LNS_extended_op 0x0
				case DW_LNS_extended_op:
					size_t n = process_extended_line_op (aPair, start);
					// if we don't understand the extended op skip to the end of the sequence :-(
					if (n == 0)
						start = end_of_sequence;
					else 
						start += n;
					break;

				case DW_LNS_copy:
					break;

				case DW_LNS_advance_pc:
				case DW_LNS_advance_line:
				case DW_LNS_set_file:
				case DW_LNS_set_column:
					ULEB128(start, bytes_read);
					break;

				case DW_LNS_negate_stmt:
				case DW_LNS_set_basic_block:
				case DW_LNS_const_add_pc:
					break;

				case DW_LNS_fixed_advance_pc:
					start += 2;
					break;

				case DW_LNS_set_prologue_end:
				case DW_LNS_set_epilogue_begin:
					break;

				case DW_LNS_set_isa:
					ULEB128(start, bytes_read);
					break;

				default:
					for (int i = standard_opcodes[op_code - 1]; i > 0 ; --i){
						ULEB128(start, bytes_read);
					}
					break;
				}
			}
		}
		// !! eek ARM seems to require header word aligned - at least for Dwarf 2
		if (aPair.iXIPFileDetails.iRVCTProduced && (version == 2))
			start = (Dwarf_Byte_Ptr)(((unsigned long)start + 3) & ~3);
	}
}