code: def _load_target(self, target, module=None):
          
  
          mod = ModuleSettings({}, {})
          if not self.validate_target(target):
              raise ArgumentError("Target %s is invalid, check to make sure every architecture in it is defined" % target)
  
          if module is not None:
              if module not in self.modules:
                  raise ArgumentError("Unknown module name passed: %s" % module)
  
              mod = self.modules[module]
  
          settings = {}
          archs = target.split('/')
  
          for arch in archs:
              arch_settings = deepcopy(self.archs[arch])
  
              if arch in mod.overlays:
                  arch_settings = merge_dicts(arch_settings, mod.overlays[arch])
  
              # Allow this architecture to overlay previous architectures as well
              if "overlays" in arch_settings:
                  for arch2 in archs:
                      if arch2 == arch:
                          break
  
                      if arch2 in arch_settings["overlays"]:
                          arch_settings = merge_dicts(arch_settings, arch_settings["overlays"][arch2])
  
                  del arch_settings["overlays"]
  
              # Allow the module to overlay included architectures as well
              if "overlays" in mod.settings and arch in mod.settings['overlays']:
                  arch_settings = merge_dicts(arch_settings, mod.settings['overlays'][arch])
  
              settings = merge_dicts(settings, arch_settings)
  
          settings = merge_dicts(settings, mod.settings)
  
          targetname = "%s:%s" % (str(module), target)
  
          return TargetSettings(targetname, settings, self)
docs: Given a string specifying a series of architectural overlays as:
          <arch 1>/<arch 2>/... and optionally a module name to pull in
          module specific settings, return a TargetSettings object that
          encapsulates all of the settings for this target.