ক্রস-কম্পাইলেশন, টুলচেইন ও বিল্ড প্রসেস

# --- মেমরি ম্যাপ (L06-এর ধারণার পুনর্ব্যবহার) -- প্রতিটি অঞ্চলের শুরু ঠিকানা ও মোট আকার (বাইটে) ---
memory_regions = {
    "FLASH": {"start": 0x08000000, "size": 256 * 1024},  # .text ও .data-এর প্রাথমিক মান এখানে থাকে
    "SRAM":  {"start": 0x20000000, "size": 64 * 1024},   # .data-এর রানটাইম কপি ও .bss এখানে থাকে
}

# --- কয়েকটি অবজেক্ট ফাইলের সেকশন সাইজ (বাইটে) -- বাস্তবে কম্পাইলার/অ্যাসেম্বলার এগুলো জেনারেট করে ---
object_files = [
    {"name": "main.o",    "text": 4200, "data": 64, "bss": 128},
    {"name": "gpio.o",    "text": 1800, "data": 0,  "bss": 4},
    {"name": "uart.o",    "text": 2600, "data": 32, "bss": 256},
    {"name": "startup.o", "text": 300,  "data": 0,  "bss": 0},
]

total_text = sum(o["text"] for o in object_files)
total_data = sum(o["data"] for o in object_files)
total_bss  = sum(o["bss"]  for o in object_files)

print("=== অবজেক্ট ফাইলের সেকশন সাইজ ===")
for o in object_files:
    print(f"  {o['name']:12s} .text={o['text']:5d}B  .data={o['data']:4d}B  .bss={o['bss']:4d}B")
print(f"  {'মোট':12s} .text={total_text:5d}B  .data={total_data:4d}B  .bss={total_bss:4d}B")

def place(region_name, size, cursor):
    """সরল বাম্প-অ্যালোকেটর -- cursor থেকে শুরু করে size বাইট বরাদ্দ করে, শেষ ঠিকানা ও fits-flag ফেরত দেয়।"""
    region = memory_regions[region_name]
    start_addr = cursor
    end_addr = cursor + size
    region_end = region["start"] + region["size"]
    fits = end_addr <= region_end
    return start_addr, end_addr, fits

print()
print("=== লিংকার প্লেসমেন্ট (বাম্প-অ্যালোকেটর) ===")

# .text -- FLASH-এ, একদম শুরু থেকে
text_start, text_end, text_fits = place("FLASH", total_text, memory_regions["FLASH"]["start"])
print(f".text    FLASH  0x{text_start:08X} - 0x{text_end:08X}  ({total_text} বাইট)  fits={text_fits}")

# .data-এর ইনিশিয়াল ভ্যালু -- FLASH-এই .text-এর ঠিক পরে
data_flash_start, data_flash_end, data_flash_fits = place("FLASH", total_data, text_end)
print(f".data(F) FLASH  0x{data_flash_start:08X} - 0x{data_flash_end:08X}  ({total_data} বাইট)  fits={data_flash_fits}")

# .data-এর রানটাইম কপি -- SRAM-এ, একদম শুরু থেকে
data_sram_start, data_sram_end, data_sram_fits = place("SRAM", total_data, memory_regions["SRAM"]["start"])
print(f".data(R) SRAM   0x{data_sram_start:08X} - 0x{data_sram_end:08X}  ({total_data} বাইট)  fits={data_sram_fits}")

# .bss -- SRAM-এ, .data-এর রানটাইম কপির ঠিক পরে (ইনিশিয়াল ভ্যালু ছাড়া, শুধু জায়গা)
bss_start, bss_end, bss_fits = place("SRAM", total_bss, data_sram_end)
print(f".bss     SRAM   0x{bss_start:08X} - 0x{bss_end:08X}  ({total_bss} বাইট)  fits={bss_fits}")

print()
all_fit = text_fits and data_flash_fits and data_sram_fits and bss_fits
print(f"=== সবকিছু বরাদ্দকৃত মেমরি রেঞ্জের মধ্যে ফিট করলো: {all_fit} ===")

flash_used = data_flash_end - memory_regions["FLASH"]["start"]
sram_used = bss_end - memory_regions["SRAM"]["start"]
flash_pct = 100 * flash_used / memory_regions["FLASH"]["size"]
sram_pct = 100 * sram_used / memory_regions["SRAM"]["size"]
print(f"FLASH ব্যবহার: {flash_used} / {memory_regions['FLASH']['size']} বাইট ({flash_pct:.2f}%)")
print(f"SRAM  ব্যবহার: {sram_used} / {memory_regions['SRAM']['size']} বাইট ({sram_pct:.2f}%)")